Machine Vision using Portenta H7 2
Loading...
Searching...
No Matches
schema_generated.h
Go to the documentation of this file.
1// automatically generated by the FlatBuffers compiler, do not modify
2
3
4#ifndef FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
5#define FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
6
8
9// Ensure the included flatbuffers.h is the same version as when this file was
10// generated, otherwise it may not be compatible.
11static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
12 FLATBUFFERS_VERSION_MINOR == 0 &&
13 FLATBUFFERS_VERSION_REVISION == 6,
14 "Non-compatible flatbuffers version included");
15
16namespace tflite {
17
18struct CustomQuantization;
19struct CustomQuantizationBuilder;
20struct CustomQuantizationT;
21
22struct QuantizationParameters;
23struct QuantizationParametersBuilder;
24struct QuantizationParametersT;
25
26struct Int32Vector;
27struct Int32VectorBuilder;
28struct Int32VectorT;
29
30struct Uint16Vector;
31struct Uint16VectorBuilder;
32struct Uint16VectorT;
33
34struct Uint8Vector;
35struct Uint8VectorBuilder;
36struct Uint8VectorT;
37
38struct DimensionMetadata;
39struct DimensionMetadataBuilder;
40struct DimensionMetadataT;
41
42struct SparsityParameters;
43struct SparsityParametersBuilder;
44struct SparsityParametersT;
45
46struct VariantSubType;
47struct VariantSubTypeBuilder;
48struct VariantSubTypeT;
49
50struct Tensor;
51struct TensorBuilder;
52struct TensorT;
53
54struct Conv2DOptions;
55struct Conv2DOptionsBuilder;
56struct Conv2DOptionsT;
57
58struct Conv3DOptions;
59struct Conv3DOptionsBuilder;
60struct Conv3DOptionsT;
61
62struct Pool2DOptions;
63struct Pool2DOptionsBuilder;
64struct Pool2DOptionsT;
65
66struct DepthwiseConv2DOptions;
67struct DepthwiseConv2DOptionsBuilder;
68struct DepthwiseConv2DOptionsT;
69
70struct ConcatEmbeddingsOptions;
71struct ConcatEmbeddingsOptionsBuilder;
72struct ConcatEmbeddingsOptionsT;
73
74struct LSHProjectionOptions;
75struct LSHProjectionOptionsBuilder;
76struct LSHProjectionOptionsT;
77
78struct SVDFOptions;
79struct SVDFOptionsBuilder;
80struct SVDFOptionsT;
81
82struct RNNOptions;
83struct RNNOptionsBuilder;
84struct RNNOptionsT;
85
86struct SequenceRNNOptions;
87struct SequenceRNNOptionsBuilder;
88struct SequenceRNNOptionsT;
89
90struct BidirectionalSequenceRNNOptions;
91struct BidirectionalSequenceRNNOptionsBuilder;
92struct BidirectionalSequenceRNNOptionsT;
93
94struct FullyConnectedOptions;
95struct FullyConnectedOptionsBuilder;
96struct FullyConnectedOptionsT;
97
98struct SoftmaxOptions;
99struct SoftmaxOptionsBuilder;
100struct SoftmaxOptionsT;
101
102struct ConcatenationOptions;
103struct ConcatenationOptionsBuilder;
104struct ConcatenationOptionsT;
105
106struct AddOptions;
107struct AddOptionsBuilder;
108struct AddOptionsT;
109
110struct MulOptions;
111struct MulOptionsBuilder;
112struct MulOptionsT;
113
114struct L2NormOptions;
115struct L2NormOptionsBuilder;
116struct L2NormOptionsT;
117
118struct LocalResponseNormalizationOptions;
119struct LocalResponseNormalizationOptionsBuilder;
120struct LocalResponseNormalizationOptionsT;
121
122struct LSTMOptions;
123struct LSTMOptionsBuilder;
124struct LSTMOptionsT;
125
126struct UnidirectionalSequenceLSTMOptions;
127struct UnidirectionalSequenceLSTMOptionsBuilder;
128struct UnidirectionalSequenceLSTMOptionsT;
129
130struct BidirectionalSequenceLSTMOptions;
131struct BidirectionalSequenceLSTMOptionsBuilder;
132struct BidirectionalSequenceLSTMOptionsT;
133
134struct ResizeBilinearOptions;
135struct ResizeBilinearOptionsBuilder;
136struct ResizeBilinearOptionsT;
137
138struct ResizeNearestNeighborOptions;
139struct ResizeNearestNeighborOptionsBuilder;
140struct ResizeNearestNeighborOptionsT;
141
142struct CallOptions;
143struct CallOptionsBuilder;
144struct CallOptionsT;
145
146struct PadOptions;
147struct PadOptionsBuilder;
148struct PadOptionsT;
149
150struct PadV2Options;
151struct PadV2OptionsBuilder;
152struct PadV2OptionsT;
153
154struct ReshapeOptions;
155struct ReshapeOptionsBuilder;
156struct ReshapeOptionsT;
157
158struct SpaceToBatchNDOptions;
159struct SpaceToBatchNDOptionsBuilder;
160struct SpaceToBatchNDOptionsT;
161
162struct BatchToSpaceNDOptions;
163struct BatchToSpaceNDOptionsBuilder;
164struct BatchToSpaceNDOptionsT;
165
166struct SkipGramOptions;
167struct SkipGramOptionsBuilder;
168struct SkipGramOptionsT;
169
170struct SpaceToDepthOptions;
171struct SpaceToDepthOptionsBuilder;
172struct SpaceToDepthOptionsT;
173
174struct DepthToSpaceOptions;
175struct DepthToSpaceOptionsBuilder;
176struct DepthToSpaceOptionsT;
177
178struct SubOptions;
179struct SubOptionsBuilder;
180struct SubOptionsT;
181
182struct DivOptions;
183struct DivOptionsBuilder;
184struct DivOptionsT;
185
186struct TopKV2Options;
187struct TopKV2OptionsBuilder;
188struct TopKV2OptionsT;
189
190struct EmbeddingLookupSparseOptions;
191struct EmbeddingLookupSparseOptionsBuilder;
192struct EmbeddingLookupSparseOptionsT;
193
194struct GatherOptions;
195struct GatherOptionsBuilder;
196struct GatherOptionsT;
197
198struct TransposeOptions;
199struct TransposeOptionsBuilder;
200struct TransposeOptionsT;
201
202struct ExpOptions;
203struct ExpOptionsBuilder;
204struct ExpOptionsT;
205
206struct CosOptions;
207struct CosOptionsBuilder;
208struct CosOptionsT;
209
210struct ReducerOptions;
211struct ReducerOptionsBuilder;
212struct ReducerOptionsT;
213
214struct SqueezeOptions;
215struct SqueezeOptionsBuilder;
216struct SqueezeOptionsT;
217
218struct SplitOptions;
219struct SplitOptionsBuilder;
220struct SplitOptionsT;
221
222struct SplitVOptions;
223struct SplitVOptionsBuilder;
224struct SplitVOptionsT;
225
226struct StridedSliceOptions;
227struct StridedSliceOptionsBuilder;
228struct StridedSliceOptionsT;
229
230struct LogSoftmaxOptions;
231struct LogSoftmaxOptionsBuilder;
232struct LogSoftmaxOptionsT;
233
234struct CastOptions;
235struct CastOptionsBuilder;
236struct CastOptionsT;
237
238struct DequantizeOptions;
239struct DequantizeOptionsBuilder;
240struct DequantizeOptionsT;
241
242struct MaximumMinimumOptions;
243struct MaximumMinimumOptionsBuilder;
244struct MaximumMinimumOptionsT;
245
246struct TileOptions;
247struct TileOptionsBuilder;
248struct TileOptionsT;
249
250struct ArgMaxOptions;
251struct ArgMaxOptionsBuilder;
252struct ArgMaxOptionsT;
253
254struct ArgMinOptions;
255struct ArgMinOptionsBuilder;
256struct ArgMinOptionsT;
257
258struct GreaterOptions;
259struct GreaterOptionsBuilder;
260struct GreaterOptionsT;
261
262struct GreaterEqualOptions;
263struct GreaterEqualOptionsBuilder;
264struct GreaterEqualOptionsT;
265
266struct LessOptions;
267struct LessOptionsBuilder;
268struct LessOptionsT;
269
270struct LessEqualOptions;
271struct LessEqualOptionsBuilder;
272struct LessEqualOptionsT;
273
274struct NegOptions;
275struct NegOptionsBuilder;
276struct NegOptionsT;
277
278struct SelectOptions;
279struct SelectOptionsBuilder;
280struct SelectOptionsT;
281
282struct SliceOptions;
283struct SliceOptionsBuilder;
284struct SliceOptionsT;
285
286struct TransposeConvOptions;
287struct TransposeConvOptionsBuilder;
288struct TransposeConvOptionsT;
289
290struct ExpandDimsOptions;
291struct ExpandDimsOptionsBuilder;
292struct ExpandDimsOptionsT;
293
294struct SparseToDenseOptions;
295struct SparseToDenseOptionsBuilder;
296struct SparseToDenseOptionsT;
297
298struct EqualOptions;
299struct EqualOptionsBuilder;
300struct EqualOptionsT;
301
302struct NotEqualOptions;
303struct NotEqualOptionsBuilder;
304struct NotEqualOptionsT;
305
306struct ShapeOptions;
307struct ShapeOptionsBuilder;
308struct ShapeOptionsT;
309
310struct RankOptions;
311struct RankOptionsBuilder;
312struct RankOptionsT;
313
314struct PowOptions;
315struct PowOptionsBuilder;
316struct PowOptionsT;
317
318struct FakeQuantOptions;
319struct FakeQuantOptionsBuilder;
320struct FakeQuantOptionsT;
321
322struct PackOptions;
323struct PackOptionsBuilder;
324struct PackOptionsT;
325
326struct LogicalOrOptions;
327struct LogicalOrOptionsBuilder;
328struct LogicalOrOptionsT;
329
330struct OneHotOptions;
331struct OneHotOptionsBuilder;
332struct OneHotOptionsT;
333
334struct AbsOptions;
335struct AbsOptionsBuilder;
336struct AbsOptionsT;
337
338struct HardSwishOptions;
339struct HardSwishOptionsBuilder;
340struct HardSwishOptionsT;
341
342struct LogicalAndOptions;
343struct LogicalAndOptionsBuilder;
344struct LogicalAndOptionsT;
345
346struct LogicalNotOptions;
347struct LogicalNotOptionsBuilder;
348struct LogicalNotOptionsT;
349
350struct UnpackOptions;
351struct UnpackOptionsBuilder;
352struct UnpackOptionsT;
353
354struct FloorDivOptions;
355struct FloorDivOptionsBuilder;
356struct FloorDivOptionsT;
357
358struct SquareOptions;
359struct SquareOptionsBuilder;
360struct SquareOptionsT;
361
362struct ZerosLikeOptions;
363struct ZerosLikeOptionsBuilder;
364struct ZerosLikeOptionsT;
365
366struct FillOptions;
367struct FillOptionsBuilder;
368struct FillOptionsT;
369
370struct FloorModOptions;
371struct FloorModOptionsBuilder;
372struct FloorModOptionsT;
373
374struct RangeOptions;
375struct RangeOptionsBuilder;
376struct RangeOptionsT;
377
378struct LeakyReluOptions;
379struct LeakyReluOptionsBuilder;
380struct LeakyReluOptionsT;
381
382struct SquaredDifferenceOptions;
383struct SquaredDifferenceOptionsBuilder;
384struct SquaredDifferenceOptionsT;
385
386struct MirrorPadOptions;
387struct MirrorPadOptionsBuilder;
388struct MirrorPadOptionsT;
389
390struct UniqueOptions;
391struct UniqueOptionsBuilder;
392struct UniqueOptionsT;
393
394struct ReverseV2Options;
395struct ReverseV2OptionsBuilder;
396struct ReverseV2OptionsT;
397
398struct AddNOptions;
399struct AddNOptionsBuilder;
400struct AddNOptionsT;
401
402struct GatherNdOptions;
403struct GatherNdOptionsBuilder;
404struct GatherNdOptionsT;
405
406struct WhereOptions;
407struct WhereOptionsBuilder;
408struct WhereOptionsT;
409
410struct ReverseSequenceOptions;
411struct ReverseSequenceOptionsBuilder;
412struct ReverseSequenceOptionsT;
413
414struct MatrixDiagOptions;
415struct MatrixDiagOptionsBuilder;
416struct MatrixDiagOptionsT;
417
418struct QuantizeOptions;
419struct QuantizeOptionsBuilder;
420struct QuantizeOptionsT;
421
422struct MatrixSetDiagOptions;
423struct MatrixSetDiagOptionsBuilder;
424struct MatrixSetDiagOptionsT;
425
426struct IfOptions;
427struct IfOptionsBuilder;
428struct IfOptionsT;
429
430struct CallOnceOptions;
431struct CallOnceOptionsBuilder;
432struct CallOnceOptionsT;
433
434struct WhileOptions;
435struct WhileOptionsBuilder;
436struct WhileOptionsT;
437
438struct NonMaxSuppressionV4Options;
439struct NonMaxSuppressionV4OptionsBuilder;
440struct NonMaxSuppressionV4OptionsT;
441
442struct NonMaxSuppressionV5Options;
443struct NonMaxSuppressionV5OptionsBuilder;
444struct NonMaxSuppressionV5OptionsT;
445
446struct ScatterNdOptions;
447struct ScatterNdOptionsBuilder;
448struct ScatterNdOptionsT;
449
450struct SelectV2Options;
451struct SelectV2OptionsBuilder;
452struct SelectV2OptionsT;
453
454struct DensifyOptions;
455struct DensifyOptionsBuilder;
456struct DensifyOptionsT;
457
458struct SegmentSumOptions;
459struct SegmentSumOptionsBuilder;
460struct SegmentSumOptionsT;
461
462struct BatchMatMulOptions;
463struct BatchMatMulOptionsBuilder;
464struct BatchMatMulOptionsT;
465
466struct CumsumOptions;
467struct CumsumOptionsBuilder;
468struct CumsumOptionsT;
469
470struct BroadcastToOptions;
471struct BroadcastToOptionsBuilder;
472struct BroadcastToOptionsT;
473
474struct Rfft2dOptions;
475struct Rfft2dOptionsBuilder;
476struct Rfft2dOptionsT;
477
478struct HashtableOptions;
479struct HashtableOptionsBuilder;
480struct HashtableOptionsT;
481
482struct HashtableFindOptions;
483struct HashtableFindOptionsBuilder;
484struct HashtableFindOptionsT;
485
486struct HashtableImportOptions;
487struct HashtableImportOptionsBuilder;
488struct HashtableImportOptionsT;
489
490struct HashtableSizeOptions;
491struct HashtableSizeOptionsBuilder;
492struct HashtableSizeOptionsT;
493
494struct VarHandleOptions;
495struct VarHandleOptionsBuilder;
496struct VarHandleOptionsT;
497
498struct ReadVariableOptions;
499struct ReadVariableOptionsBuilder;
500struct ReadVariableOptionsT;
501
502struct AssignVariableOptions;
503struct AssignVariableOptionsBuilder;
504struct AssignVariableOptionsT;
505
506struct RandomOptions;
507struct RandomOptionsBuilder;
508struct RandomOptionsT;
509
510struct BucketizeOptions;
511struct BucketizeOptionsBuilder;
512struct BucketizeOptionsT;
513
514struct GeluOptions;
515struct GeluOptionsBuilder;
516struct GeluOptionsT;
517
518struct DynamicUpdateSliceOptions;
519struct DynamicUpdateSliceOptionsBuilder;
520struct DynamicUpdateSliceOptionsT;
521
522struct UnsortedSegmentProdOptions;
523struct UnsortedSegmentProdOptionsBuilder;
524struct UnsortedSegmentProdOptionsT;
525
526struct UnsortedSegmentMaxOptions;
527struct UnsortedSegmentMaxOptionsBuilder;
528struct UnsortedSegmentMaxOptionsT;
529
530struct UnsortedSegmentSumOptions;
531struct UnsortedSegmentSumOptionsBuilder;
532struct UnsortedSegmentSumOptionsT;
533
534struct ATan2Options;
535struct ATan2OptionsBuilder;
536struct ATan2OptionsT;
537
538struct UnsortedSegmentMinOptions;
539struct UnsortedSegmentMinOptionsBuilder;
540struct UnsortedSegmentMinOptionsT;
541
542struct SignOptions;
543struct SignOptionsBuilder;
544struct SignOptionsT;
545
546struct OperatorCode;
547struct OperatorCodeBuilder;
548struct OperatorCodeT;
549
550struct Operator;
551struct OperatorBuilder;
552struct OperatorT;
553
554struct SubGraph;
555struct SubGraphBuilder;
556struct SubGraphT;
557
558struct Buffer;
559struct BufferBuilder;
560struct BufferT;
561
562struct Metadata;
563struct MetadataBuilder;
564struct MetadataT;
565
566struct TensorMap;
567struct TensorMapBuilder;
568struct TensorMapT;
569
570struct SignatureDef;
571struct SignatureDefBuilder;
572struct SignatureDefT;
573
574struct Model;
575struct ModelBuilder;
576struct ModelT;
577
600
624
625inline const char * const *EnumNamesTensorType() {
626 static const char * const names[19] = {
627 "FLOAT32",
628 "FLOAT16",
629 "INT32",
630 "UINT8",
631 "INT64",
632 "STRING",
633 "BOOL",
634 "INT16",
635 "COMPLEX64",
636 "INT8",
637 "FLOAT64",
638 "COMPLEX128",
639 "UINT64",
640 "RESOURCE",
641 "VARIANT",
642 "UINT32",
643 "UINT16",
644 "INT4",
645 nullptr
646 };
647 return names;
648}
649
650inline const char *EnumNameTensorType(TensorType e) {
651 if (flatbuffers::IsOutRange(e, TensorType_FLOAT32, TensorType_INT4)) return "";
652 const size_t index = static_cast<size_t>(e);
653 return EnumNamesTensorType()[index];
654}
655
662
664 static const QuantizationDetails values[] = {
667 };
668 return values;
669}
670
671inline const char * const *EnumNamesQuantizationDetails() {
672 static const char * const names[3] = {
673 "NONE",
674 "CustomQuantization",
675 nullptr
676 };
677 return names;
678}
679
681 if (flatbuffers::IsOutRange(e, QuantizationDetails_NONE, QuantizationDetails_CustomQuantization)) return "";
682 const size_t index = static_cast<size_t>(e);
683 return EnumNamesQuantizationDetails()[index];
684}
685
686template<typename T> struct QuantizationDetailsTraits {
688};
689
690template<> struct QuantizationDetailsTraits<tflite::CustomQuantization> {
692};
693
694template<typename T> struct QuantizationDetailsUnionTraits {
696};
697
700};
701
704 void *value;
705
709 { std::swap(type, u.type); std::swap(value, u.value); }
712 { QuantizationDetailsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
714 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
716
717 void Reset();
718
719 template <typename T>
720 void Set(T&& val) {
721 typedef typename std::remove_reference<T>::type RT;
722 Reset();
725 value = new RT(std::forward<T>(val));
726 }
727 }
728
729 static void *UnPack(const void *obj, QuantizationDetails type, const flatbuffers::resolver_function_t *resolver);
730 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
731
738 reinterpret_cast<const tflite::CustomQuantizationT *>(value) : nullptr;
739 }
740};
741
742bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type);
743bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
744
751
753 static const DimensionType values[] = {
756 };
757 return values;
758}
759
760inline const char * const *EnumNamesDimensionType() {
761 static const char * const names[3] = {
762 "DENSE",
763 "SPARSE_CSR",
764 nullptr
765 };
766 return names;
767}
768
770 if (flatbuffers::IsOutRange(e, DimensionType_DENSE, DimensionType_SPARSE_CSR)) return "";
771 const size_t index = static_cast<size_t>(e);
772 return EnumNamesDimensionType()[index];
773}
774
783
793
794inline const char * const *EnumNamesSparseIndexVector() {
795 static const char * const names[5] = {
796 "NONE",
797 "Int32Vector",
798 "Uint16Vector",
799 "Uint8Vector",
800 nullptr
801 };
802 return names;
803}
804
806 if (flatbuffers::IsOutRange(e, SparseIndexVector_NONE, SparseIndexVector_Uint8Vector)) return "";
807 const size_t index = static_cast<size_t>(e);
808 return EnumNamesSparseIndexVector()[index];
809}
810
811template<typename T> struct SparseIndexVectorTraits {
813};
814
815template<> struct SparseIndexVectorTraits<tflite::Int32Vector> {
817};
818
819template<> struct SparseIndexVectorTraits<tflite::Uint16Vector> {
821};
822
823template<> struct SparseIndexVectorTraits<tflite::Uint8Vector> {
825};
826
827template<typename T> struct SparseIndexVectorUnionTraits {
829};
830
833};
834
837};
838
841};
842
845 void *value;
846
850 { std::swap(type, u.type); std::swap(value, u.value); }
853 { SparseIndexVectorUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
855 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
857
858 void Reset();
859
860 template <typename T>
861 void Set(T&& val) {
862 typedef typename std::remove_reference<T>::type RT;
863 Reset();
866 value = new RT(std::forward<T>(val));
867 }
868 }
869
870 static void *UnPack(const void *obj, SparseIndexVector type, const flatbuffers::resolver_function_t *resolver);
871 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
872
875 reinterpret_cast<tflite::Int32VectorT *>(value) : nullptr;
876 }
879 reinterpret_cast<const tflite::Int32VectorT *>(value) : nullptr;
880 }
883 reinterpret_cast<tflite::Uint16VectorT *>(value) : nullptr;
884 }
887 reinterpret_cast<const tflite::Uint16VectorT *>(value) : nullptr;
888 }
891 reinterpret_cast<tflite::Uint8VectorT *>(value) : nullptr;
892 }
895 reinterpret_cast<const tflite::Uint8VectorT *>(value) : nullptr;
896 }
897};
898
899bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type);
900bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
901
902enum BuiltinOperator : int32_t {
1065
1067 static const BuiltinOperator values[] = {
1227 };
1228 return values;
1229}
1230
1231inline const char * const *EnumNamesBuiltinOperator() {
1232 static const char * const names[160] = {
1233 "ADD",
1234 "AVERAGE_POOL_2D",
1235 "CONCATENATION",
1236 "CONV_2D",
1237 "DEPTHWISE_CONV_2D",
1238 "DEPTH_TO_SPACE",
1239 "DEQUANTIZE",
1240 "EMBEDDING_LOOKUP",
1241 "FLOOR",
1242 "FULLY_CONNECTED",
1243 "HASHTABLE_LOOKUP",
1244 "L2_NORMALIZATION",
1245 "L2_POOL_2D",
1246 "LOCAL_RESPONSE_NORMALIZATION",
1247 "LOGISTIC",
1248 "LSH_PROJECTION",
1249 "LSTM",
1250 "MAX_POOL_2D",
1251 "MUL",
1252 "RELU",
1253 "RELU_N1_TO_1",
1254 "RELU6",
1255 "RESHAPE",
1256 "RESIZE_BILINEAR",
1257 "RNN",
1258 "SOFTMAX",
1259 "SPACE_TO_DEPTH",
1260 "SVDF",
1261 "TANH",
1262 "CONCAT_EMBEDDINGS",
1263 "SKIP_GRAM",
1264 "CALL",
1265 "CUSTOM",
1266 "EMBEDDING_LOOKUP_SPARSE",
1267 "PAD",
1268 "UNIDIRECTIONAL_SEQUENCE_RNN",
1269 "GATHER",
1270 "BATCH_TO_SPACE_ND",
1271 "SPACE_TO_BATCH_ND",
1272 "TRANSPOSE",
1273 "MEAN",
1274 "SUB",
1275 "DIV",
1276 "SQUEEZE",
1277 "UNIDIRECTIONAL_SEQUENCE_LSTM",
1278 "STRIDED_SLICE",
1279 "BIDIRECTIONAL_SEQUENCE_RNN",
1280 "EXP",
1281 "TOPK_V2",
1282 "SPLIT",
1283 "LOG_SOFTMAX",
1284 "DELEGATE",
1285 "BIDIRECTIONAL_SEQUENCE_LSTM",
1286 "CAST",
1287 "PRELU",
1288 "MAXIMUM",
1289 "ARG_MAX",
1290 "MINIMUM",
1291 "LESS",
1292 "NEG",
1293 "PADV2",
1294 "GREATER",
1295 "GREATER_EQUAL",
1296 "LESS_EQUAL",
1297 "SELECT",
1298 "SLICE",
1299 "SIN",
1300 "TRANSPOSE_CONV",
1301 "SPARSE_TO_DENSE",
1302 "TILE",
1303 "EXPAND_DIMS",
1304 "EQUAL",
1305 "NOT_EQUAL",
1306 "LOG",
1307 "SUM",
1308 "SQRT",
1309 "RSQRT",
1310 "SHAPE",
1311 "POW",
1312 "ARG_MIN",
1313 "FAKE_QUANT",
1314 "REDUCE_PROD",
1315 "REDUCE_MAX",
1316 "PACK",
1317 "LOGICAL_OR",
1318 "ONE_HOT",
1319 "LOGICAL_AND",
1320 "LOGICAL_NOT",
1321 "UNPACK",
1322 "REDUCE_MIN",
1323 "FLOOR_DIV",
1324 "REDUCE_ANY",
1325 "SQUARE",
1326 "ZEROS_LIKE",
1327 "FILL",
1328 "FLOOR_MOD",
1329 "RANGE",
1330 "RESIZE_NEAREST_NEIGHBOR",
1331 "LEAKY_RELU",
1332 "SQUARED_DIFFERENCE",
1333 "MIRROR_PAD",
1334 "ABS",
1335 "SPLIT_V",
1336 "UNIQUE",
1337 "CEIL",
1338 "REVERSE_V2",
1339 "ADD_N",
1340 "GATHER_ND",
1341 "COS",
1342 "WHERE",
1343 "RANK",
1344 "ELU",
1345 "REVERSE_SEQUENCE",
1346 "MATRIX_DIAG",
1347 "QUANTIZE",
1348 "MATRIX_SET_DIAG",
1349 "ROUND",
1350 "HARD_SWISH",
1351 "IF",
1352 "WHILE",
1353 "NON_MAX_SUPPRESSION_V4",
1354 "NON_MAX_SUPPRESSION_V5",
1355 "SCATTER_ND",
1356 "SELECT_V2",
1357 "DENSIFY",
1358 "SEGMENT_SUM",
1359 "BATCH_MATMUL",
1360 "PLACEHOLDER_FOR_GREATER_OP_CODES",
1361 "CUMSUM",
1362 "CALL_ONCE",
1363 "BROADCAST_TO",
1364 "RFFT2D",
1365 "CONV_3D",
1366 "IMAG",
1367 "REAL",
1368 "COMPLEX_ABS",
1369 "HASHTABLE",
1370 "HASHTABLE_FIND",
1371 "HASHTABLE_IMPORT",
1372 "HASHTABLE_SIZE",
1373 "REDUCE_ALL",
1374 "CONV_3D_TRANSPOSE",
1375 "VAR_HANDLE",
1376 "READ_VARIABLE",
1377 "ASSIGN_VARIABLE",
1378 "BROADCAST_ARGS",
1379 "RANDOM_STANDARD_NORMAL",
1380 "BUCKETIZE",
1381 "RANDOM_UNIFORM",
1382 "MULTINOMIAL",
1383 "GELU",
1384 "DYNAMIC_UPDATE_SLICE",
1385 "RELU_0_TO_1",
1386 "UNSORTED_SEGMENT_PROD",
1387 "UNSORTED_SEGMENT_MAX",
1388 "UNSORTED_SEGMENT_SUM",
1389 "ATAN2",
1390 "UNSORTED_SEGMENT_MIN",
1391 "SIGN",
1392 nullptr
1393 };
1394 return names;
1395}
1396
1398 if (flatbuffers::IsOutRange(e, BuiltinOperator_ADD, BuiltinOperator_SIGN)) return "";
1399 const size_t index = static_cast<size_t>(e);
1400 return EnumNamesBuiltinOperator()[index];
1401}
1402
1403enum BuiltinOptions : uint8_t {
1531
1533 static const BuiltinOptions values[] = {
1658 };
1659 return values;
1660}
1661
1662inline const char * const *EnumNamesBuiltinOptions() {
1663 static const char * const names[125] = {
1664 "NONE",
1665 "Conv2DOptions",
1666 "DepthwiseConv2DOptions",
1667 "ConcatEmbeddingsOptions",
1668 "LSHProjectionOptions",
1669 "Pool2DOptions",
1670 "SVDFOptions",
1671 "RNNOptions",
1672 "FullyConnectedOptions",
1673 "SoftmaxOptions",
1674 "ConcatenationOptions",
1675 "AddOptions",
1676 "L2NormOptions",
1677 "LocalResponseNormalizationOptions",
1678 "LSTMOptions",
1679 "ResizeBilinearOptions",
1680 "CallOptions",
1681 "ReshapeOptions",
1682 "SkipGramOptions",
1683 "SpaceToDepthOptions",
1684 "EmbeddingLookupSparseOptions",
1685 "MulOptions",
1686 "PadOptions",
1687 "GatherOptions",
1688 "BatchToSpaceNDOptions",
1689 "SpaceToBatchNDOptions",
1690 "TransposeOptions",
1691 "ReducerOptions",
1692 "SubOptions",
1693 "DivOptions",
1694 "SqueezeOptions",
1695 "SequenceRNNOptions",
1696 "StridedSliceOptions",
1697 "ExpOptions",
1698 "TopKV2Options",
1699 "SplitOptions",
1700 "LogSoftmaxOptions",
1701 "CastOptions",
1702 "DequantizeOptions",
1703 "MaximumMinimumOptions",
1704 "ArgMaxOptions",
1705 "LessOptions",
1706 "NegOptions",
1707 "PadV2Options",
1708 "GreaterOptions",
1709 "GreaterEqualOptions",
1710 "LessEqualOptions",
1711 "SelectOptions",
1712 "SliceOptions",
1713 "TransposeConvOptions",
1714 "SparseToDenseOptions",
1715 "TileOptions",
1716 "ExpandDimsOptions",
1717 "EqualOptions",
1718 "NotEqualOptions",
1719 "ShapeOptions",
1720 "PowOptions",
1721 "ArgMinOptions",
1722 "FakeQuantOptions",
1723 "PackOptions",
1724 "LogicalOrOptions",
1725 "OneHotOptions",
1726 "LogicalAndOptions",
1727 "LogicalNotOptions",
1728 "UnpackOptions",
1729 "FloorDivOptions",
1730 "SquareOptions",
1731 "ZerosLikeOptions",
1732 "FillOptions",
1733 "BidirectionalSequenceLSTMOptions",
1734 "BidirectionalSequenceRNNOptions",
1735 "UnidirectionalSequenceLSTMOptions",
1736 "FloorModOptions",
1737 "RangeOptions",
1738 "ResizeNearestNeighborOptions",
1739 "LeakyReluOptions",
1740 "SquaredDifferenceOptions",
1741 "MirrorPadOptions",
1742 "AbsOptions",
1743 "SplitVOptions",
1744 "UniqueOptions",
1745 "ReverseV2Options",
1746 "AddNOptions",
1747 "GatherNdOptions",
1748 "CosOptions",
1749 "WhereOptions",
1750 "RankOptions",
1751 "ReverseSequenceOptions",
1752 "MatrixDiagOptions",
1753 "QuantizeOptions",
1754 "MatrixSetDiagOptions",
1755 "HardSwishOptions",
1756 "IfOptions",
1757 "WhileOptions",
1758 "DepthToSpaceOptions",
1759 "NonMaxSuppressionV4Options",
1760 "NonMaxSuppressionV5Options",
1761 "ScatterNdOptions",
1762 "SelectV2Options",
1763 "DensifyOptions",
1764 "SegmentSumOptions",
1765 "BatchMatMulOptions",
1766 "CumsumOptions",
1767 "CallOnceOptions",
1768 "BroadcastToOptions",
1769 "Rfft2dOptions",
1770 "Conv3DOptions",
1771 "HashtableOptions",
1772 "HashtableFindOptions",
1773 "HashtableImportOptions",
1774 "HashtableSizeOptions",
1775 "VarHandleOptions",
1776 "ReadVariableOptions",
1777 "AssignVariableOptions",
1778 "RandomOptions",
1779 "BucketizeOptions",
1780 "GeluOptions",
1781 "DynamicUpdateSliceOptions",
1782 "UnsortedSegmentProdOptions",
1783 "UnsortedSegmentMaxOptions",
1784 "UnsortedSegmentMinOptions",
1785 "UnsortedSegmentSumOptions",
1786 "ATan2Options",
1787 "SignOptions",
1788 nullptr
1789 };
1790 return names;
1791}
1792
1794 if (flatbuffers::IsOutRange(e, BuiltinOptions_NONE, BuiltinOptions_SignOptions)) return "";
1795 const size_t index = static_cast<size_t>(e);
1796 return EnumNamesBuiltinOptions()[index];
1797}
1798
1799template<typename T> struct BuiltinOptionsTraits {
1801};
1802
1803template<> struct BuiltinOptionsTraits<tflite::Conv2DOptions> {
1805};
1806
1807template<> struct BuiltinOptionsTraits<tflite::DepthwiseConv2DOptions> {
1809};
1810
1811template<> struct BuiltinOptionsTraits<tflite::ConcatEmbeddingsOptions> {
1813};
1814
1815template<> struct BuiltinOptionsTraits<tflite::LSHProjectionOptions> {
1817};
1818
1819template<> struct BuiltinOptionsTraits<tflite::Pool2DOptions> {
1821};
1822
1823template<> struct BuiltinOptionsTraits<tflite::SVDFOptions> {
1825};
1826
1827template<> struct BuiltinOptionsTraits<tflite::RNNOptions> {
1829};
1830
1831template<> struct BuiltinOptionsTraits<tflite::FullyConnectedOptions> {
1833};
1834
1835template<> struct BuiltinOptionsTraits<tflite::SoftmaxOptions> {
1837};
1838
1839template<> struct BuiltinOptionsTraits<tflite::ConcatenationOptions> {
1841};
1842
1843template<> struct BuiltinOptionsTraits<tflite::AddOptions> {
1845};
1846
1847template<> struct BuiltinOptionsTraits<tflite::L2NormOptions> {
1849};
1850
1851template<> struct BuiltinOptionsTraits<tflite::LocalResponseNormalizationOptions> {
1853};
1854
1855template<> struct BuiltinOptionsTraits<tflite::LSTMOptions> {
1857};
1858
1859template<> struct BuiltinOptionsTraits<tflite::ResizeBilinearOptions> {
1861};
1862
1863template<> struct BuiltinOptionsTraits<tflite::CallOptions> {
1865};
1866
1867template<> struct BuiltinOptionsTraits<tflite::ReshapeOptions> {
1869};
1870
1871template<> struct BuiltinOptionsTraits<tflite::SkipGramOptions> {
1873};
1874
1875template<> struct BuiltinOptionsTraits<tflite::SpaceToDepthOptions> {
1877};
1878
1879template<> struct BuiltinOptionsTraits<tflite::EmbeddingLookupSparseOptions> {
1881};
1882
1883template<> struct BuiltinOptionsTraits<tflite::MulOptions> {
1885};
1886
1887template<> struct BuiltinOptionsTraits<tflite::PadOptions> {
1889};
1890
1891template<> struct BuiltinOptionsTraits<tflite::GatherOptions> {
1893};
1894
1895template<> struct BuiltinOptionsTraits<tflite::BatchToSpaceNDOptions> {
1897};
1898
1899template<> struct BuiltinOptionsTraits<tflite::SpaceToBatchNDOptions> {
1901};
1902
1903template<> struct BuiltinOptionsTraits<tflite::TransposeOptions> {
1905};
1906
1907template<> struct BuiltinOptionsTraits<tflite::ReducerOptions> {
1909};
1910
1911template<> struct BuiltinOptionsTraits<tflite::SubOptions> {
1913};
1914
1915template<> struct BuiltinOptionsTraits<tflite::DivOptions> {
1917};
1918
1919template<> struct BuiltinOptionsTraits<tflite::SqueezeOptions> {
1921};
1922
1923template<> struct BuiltinOptionsTraits<tflite::SequenceRNNOptions> {
1925};
1926
1927template<> struct BuiltinOptionsTraits<tflite::StridedSliceOptions> {
1929};
1930
1931template<> struct BuiltinOptionsTraits<tflite::ExpOptions> {
1933};
1934
1935template<> struct BuiltinOptionsTraits<tflite::TopKV2Options> {
1937};
1938
1939template<> struct BuiltinOptionsTraits<tflite::SplitOptions> {
1941};
1942
1943template<> struct BuiltinOptionsTraits<tflite::LogSoftmaxOptions> {
1945};
1946
1947template<> struct BuiltinOptionsTraits<tflite::CastOptions> {
1949};
1950
1951template<> struct BuiltinOptionsTraits<tflite::DequantizeOptions> {
1953};
1954
1955template<> struct BuiltinOptionsTraits<tflite::MaximumMinimumOptions> {
1957};
1958
1959template<> struct BuiltinOptionsTraits<tflite::ArgMaxOptions> {
1961};
1962
1963template<> struct BuiltinOptionsTraits<tflite::LessOptions> {
1965};
1966
1967template<> struct BuiltinOptionsTraits<tflite::NegOptions> {
1969};
1970
1971template<> struct BuiltinOptionsTraits<tflite::PadV2Options> {
1973};
1974
1975template<> struct BuiltinOptionsTraits<tflite::GreaterOptions> {
1977};
1978
1979template<> struct BuiltinOptionsTraits<tflite::GreaterEqualOptions> {
1981};
1982
1983template<> struct BuiltinOptionsTraits<tflite::LessEqualOptions> {
1985};
1986
1987template<> struct BuiltinOptionsTraits<tflite::SelectOptions> {
1989};
1990
1991template<> struct BuiltinOptionsTraits<tflite::SliceOptions> {
1993};
1994
1995template<> struct BuiltinOptionsTraits<tflite::TransposeConvOptions> {
1997};
1998
1999template<> struct BuiltinOptionsTraits<tflite::SparseToDenseOptions> {
2001};
2002
2003template<> struct BuiltinOptionsTraits<tflite::TileOptions> {
2005};
2006
2007template<> struct BuiltinOptionsTraits<tflite::ExpandDimsOptions> {
2009};
2010
2011template<> struct BuiltinOptionsTraits<tflite::EqualOptions> {
2013};
2014
2015template<> struct BuiltinOptionsTraits<tflite::NotEqualOptions> {
2017};
2018
2019template<> struct BuiltinOptionsTraits<tflite::ShapeOptions> {
2021};
2022
2023template<> struct BuiltinOptionsTraits<tflite::PowOptions> {
2025};
2026
2027template<> struct BuiltinOptionsTraits<tflite::ArgMinOptions> {
2029};
2030
2031template<> struct BuiltinOptionsTraits<tflite::FakeQuantOptions> {
2033};
2034
2035template<> struct BuiltinOptionsTraits<tflite::PackOptions> {
2037};
2038
2039template<> struct BuiltinOptionsTraits<tflite::LogicalOrOptions> {
2041};
2042
2043template<> struct BuiltinOptionsTraits<tflite::OneHotOptions> {
2045};
2046
2047template<> struct BuiltinOptionsTraits<tflite::LogicalAndOptions> {
2049};
2050
2051template<> struct BuiltinOptionsTraits<tflite::LogicalNotOptions> {
2053};
2054
2055template<> struct BuiltinOptionsTraits<tflite::UnpackOptions> {
2057};
2058
2059template<> struct BuiltinOptionsTraits<tflite::FloorDivOptions> {
2061};
2062
2063template<> struct BuiltinOptionsTraits<tflite::SquareOptions> {
2065};
2066
2067template<> struct BuiltinOptionsTraits<tflite::ZerosLikeOptions> {
2069};
2070
2071template<> struct BuiltinOptionsTraits<tflite::FillOptions> {
2073};
2074
2075template<> struct BuiltinOptionsTraits<tflite::BidirectionalSequenceLSTMOptions> {
2077};
2078
2079template<> struct BuiltinOptionsTraits<tflite::BidirectionalSequenceRNNOptions> {
2081};
2082
2083template<> struct BuiltinOptionsTraits<tflite::UnidirectionalSequenceLSTMOptions> {
2085};
2086
2087template<> struct BuiltinOptionsTraits<tflite::FloorModOptions> {
2089};
2090
2091template<> struct BuiltinOptionsTraits<tflite::RangeOptions> {
2093};
2094
2095template<> struct BuiltinOptionsTraits<tflite::ResizeNearestNeighborOptions> {
2097};
2098
2099template<> struct BuiltinOptionsTraits<tflite::LeakyReluOptions> {
2101};
2102
2103template<> struct BuiltinOptionsTraits<tflite::SquaredDifferenceOptions> {
2105};
2106
2107template<> struct BuiltinOptionsTraits<tflite::MirrorPadOptions> {
2109};
2110
2111template<> struct BuiltinOptionsTraits<tflite::AbsOptions> {
2113};
2114
2115template<> struct BuiltinOptionsTraits<tflite::SplitVOptions> {
2117};
2118
2119template<> struct BuiltinOptionsTraits<tflite::UniqueOptions> {
2121};
2122
2123template<> struct BuiltinOptionsTraits<tflite::ReverseV2Options> {
2125};
2126
2127template<> struct BuiltinOptionsTraits<tflite::AddNOptions> {
2129};
2130
2131template<> struct BuiltinOptionsTraits<tflite::GatherNdOptions> {
2133};
2134
2135template<> struct BuiltinOptionsTraits<tflite::CosOptions> {
2137};
2138
2139template<> struct BuiltinOptionsTraits<tflite::WhereOptions> {
2141};
2142
2143template<> struct BuiltinOptionsTraits<tflite::RankOptions> {
2145};
2146
2147template<> struct BuiltinOptionsTraits<tflite::ReverseSequenceOptions> {
2149};
2150
2151template<> struct BuiltinOptionsTraits<tflite::MatrixDiagOptions> {
2153};
2154
2155template<> struct BuiltinOptionsTraits<tflite::QuantizeOptions> {
2157};
2158
2159template<> struct BuiltinOptionsTraits<tflite::MatrixSetDiagOptions> {
2161};
2162
2163template<> struct BuiltinOptionsTraits<tflite::HardSwishOptions> {
2165};
2166
2167template<> struct BuiltinOptionsTraits<tflite::IfOptions> {
2169};
2170
2171template<> struct BuiltinOptionsTraits<tflite::WhileOptions> {
2173};
2174
2175template<> struct BuiltinOptionsTraits<tflite::DepthToSpaceOptions> {
2177};
2178
2179template<> struct BuiltinOptionsTraits<tflite::NonMaxSuppressionV4Options> {
2181};
2182
2183template<> struct BuiltinOptionsTraits<tflite::NonMaxSuppressionV5Options> {
2185};
2186
2187template<> struct BuiltinOptionsTraits<tflite::ScatterNdOptions> {
2189};
2190
2191template<> struct BuiltinOptionsTraits<tflite::SelectV2Options> {
2193};
2194
2195template<> struct BuiltinOptionsTraits<tflite::DensifyOptions> {
2197};
2198
2199template<> struct BuiltinOptionsTraits<tflite::SegmentSumOptions> {
2201};
2202
2203template<> struct BuiltinOptionsTraits<tflite::BatchMatMulOptions> {
2205};
2206
2207template<> struct BuiltinOptionsTraits<tflite::CumsumOptions> {
2209};
2210
2211template<> struct BuiltinOptionsTraits<tflite::CallOnceOptions> {
2213};
2214
2215template<> struct BuiltinOptionsTraits<tflite::BroadcastToOptions> {
2217};
2218
2219template<> struct BuiltinOptionsTraits<tflite::Rfft2dOptions> {
2221};
2222
2223template<> struct BuiltinOptionsTraits<tflite::Conv3DOptions> {
2225};
2226
2227template<> struct BuiltinOptionsTraits<tflite::HashtableOptions> {
2229};
2230
2231template<> struct BuiltinOptionsTraits<tflite::HashtableFindOptions> {
2233};
2234
2235template<> struct BuiltinOptionsTraits<tflite::HashtableImportOptions> {
2237};
2238
2239template<> struct BuiltinOptionsTraits<tflite::HashtableSizeOptions> {
2241};
2242
2243template<> struct BuiltinOptionsTraits<tflite::VarHandleOptions> {
2245};
2246
2247template<> struct BuiltinOptionsTraits<tflite::ReadVariableOptions> {
2249};
2250
2251template<> struct BuiltinOptionsTraits<tflite::AssignVariableOptions> {
2253};
2254
2255template<> struct BuiltinOptionsTraits<tflite::RandomOptions> {
2257};
2258
2259template<> struct BuiltinOptionsTraits<tflite::BucketizeOptions> {
2261};
2262
2263template<> struct BuiltinOptionsTraits<tflite::GeluOptions> {
2265};
2266
2267template<> struct BuiltinOptionsTraits<tflite::DynamicUpdateSliceOptions> {
2269};
2270
2271template<> struct BuiltinOptionsTraits<tflite::UnsortedSegmentProdOptions> {
2273};
2274
2275template<> struct BuiltinOptionsTraits<tflite::UnsortedSegmentMaxOptions> {
2277};
2278
2279template<> struct BuiltinOptionsTraits<tflite::UnsortedSegmentMinOptions> {
2281};
2282
2283template<> struct BuiltinOptionsTraits<tflite::UnsortedSegmentSumOptions> {
2285};
2286
2287template<> struct BuiltinOptionsTraits<tflite::ATan2Options> {
2289};
2290
2291template<> struct BuiltinOptionsTraits<tflite::SignOptions> {
2293};
2294
2295template<typename T> struct BuiltinOptionsUnionTraits {
2297};
2298
2301};
2302
2305};
2306
2309};
2310
2313};
2314
2317};
2318
2319template<> struct BuiltinOptionsUnionTraits<tflite::SVDFOptionsT> {
2321};
2322
2323template<> struct BuiltinOptionsUnionTraits<tflite::RNNOptionsT> {
2325};
2326
2329};
2330
2333};
2334
2337};
2338
2339template<> struct BuiltinOptionsUnionTraits<tflite::AddOptionsT> {
2341};
2342
2345};
2346
2349};
2350
2351template<> struct BuiltinOptionsUnionTraits<tflite::LSTMOptionsT> {
2353};
2354
2357};
2358
2359template<> struct BuiltinOptionsUnionTraits<tflite::CallOptionsT> {
2361};
2362
2365};
2366
2369};
2370
2373};
2374
2377};
2378
2379template<> struct BuiltinOptionsUnionTraits<tflite::MulOptionsT> {
2381};
2382
2383template<> struct BuiltinOptionsUnionTraits<tflite::PadOptionsT> {
2385};
2386
2389};
2390
2393};
2394
2397};
2398
2401};
2402
2405};
2406
2407template<> struct BuiltinOptionsUnionTraits<tflite::SubOptionsT> {
2409};
2410
2411template<> struct BuiltinOptionsUnionTraits<tflite::DivOptionsT> {
2413};
2414
2417};
2418
2421};
2422
2425};
2426
2427template<> struct BuiltinOptionsUnionTraits<tflite::ExpOptionsT> {
2429};
2430
2433};
2434
2437};
2438
2441};
2442
2443template<> struct BuiltinOptionsUnionTraits<tflite::CastOptionsT> {
2445};
2446
2449};
2450
2453};
2454
2457};
2458
2459template<> struct BuiltinOptionsUnionTraits<tflite::LessOptionsT> {
2461};
2462
2463template<> struct BuiltinOptionsUnionTraits<tflite::NegOptionsT> {
2465};
2466
2469};
2470
2473};
2474
2477};
2478
2481};
2482
2485};
2486
2489};
2490
2493};
2494
2497};
2498
2499template<> struct BuiltinOptionsUnionTraits<tflite::TileOptionsT> {
2501};
2502
2505};
2506
2509};
2510
2513};
2514
2517};
2518
2519template<> struct BuiltinOptionsUnionTraits<tflite::PowOptionsT> {
2521};
2522
2525};
2526
2529};
2530
2531template<> struct BuiltinOptionsUnionTraits<tflite::PackOptionsT> {
2533};
2534
2537};
2538
2541};
2542
2545};
2546
2549};
2550
2553};
2554
2557};
2558
2561};
2562
2565};
2566
2567template<> struct BuiltinOptionsUnionTraits<tflite::FillOptionsT> {
2569};
2570
2573};
2574
2577};
2578
2581};
2582
2585};
2586
2589};
2590
2593};
2594
2597};
2598
2601};
2602
2605};
2606
2607template<> struct BuiltinOptionsUnionTraits<tflite::AbsOptionsT> {
2609};
2610
2613};
2614
2617};
2618
2621};
2622
2623template<> struct BuiltinOptionsUnionTraits<tflite::AddNOptionsT> {
2625};
2626
2629};
2630
2631template<> struct BuiltinOptionsUnionTraits<tflite::CosOptionsT> {
2633};
2634
2637};
2638
2639template<> struct BuiltinOptionsUnionTraits<tflite::RankOptionsT> {
2641};
2642
2645};
2646
2649};
2650
2653};
2654
2657};
2658
2661};
2662
2663template<> struct BuiltinOptionsUnionTraits<tflite::IfOptionsT> {
2665};
2666
2669};
2670
2673};
2674
2677};
2678
2681};
2682
2685};
2686
2689};
2690
2693};
2694
2697};
2698
2701};
2702
2705};
2706
2709};
2710
2713};
2714
2717};
2718
2721};
2722
2725};
2726
2729};
2730
2733};
2734
2737};
2738
2741};
2742
2745};
2746
2749};
2750
2753};
2754
2757};
2758
2759template<> struct BuiltinOptionsUnionTraits<tflite::GeluOptionsT> {
2761};
2762
2765};
2766
2769};
2770
2773};
2774
2777};
2778
2781};
2782
2785};
2786
2787template<> struct BuiltinOptionsUnionTraits<tflite::SignOptionsT> {
2789};
2790
2791struct BuiltinOptionsUnion {
2793 void *value;
2794
2796 BuiltinOptionsUnion(BuiltinOptionsUnion&& u) FLATBUFFERS_NOEXCEPT :
2797 type(BuiltinOptions_NONE), value(nullptr)
2798 { std::swap(type, u.type); std::swap(value, u.value); }
2801 { BuiltinOptionsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
2803 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
2805
2806 void Reset();
2807
2808 template <typename T>
2809 void Set(T&& val) {
2810 typedef typename std::remove_reference<T>::type RT;
2811 Reset();
2813 if (type != BuiltinOptions_NONE) {
2814 value = new RT(std::forward<T>(val));
2815 }
2816 }
2817
2818 static void *UnPack(const void *obj, BuiltinOptions type, const flatbuffers::resolver_function_t *resolver);
2819 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
2820
2823 reinterpret_cast<tflite::Conv2DOptionsT *>(value) : nullptr;
2824 }
2827 reinterpret_cast<const tflite::Conv2DOptionsT *>(value) : nullptr;
2828 }
2851 reinterpret_cast<const tflite::LSHProjectionOptionsT *>(value) : nullptr;
2852 }
2855 reinterpret_cast<tflite::Pool2DOptionsT *>(value) : nullptr;
2856 }
2859 reinterpret_cast<const tflite::Pool2DOptionsT *>(value) : nullptr;
2860 }
2863 reinterpret_cast<tflite::SVDFOptionsT *>(value) : nullptr;
2864 }
2867 reinterpret_cast<const tflite::SVDFOptionsT *>(value) : nullptr;
2868 }
2871 reinterpret_cast<tflite::RNNOptionsT *>(value) : nullptr;
2872 }
2875 reinterpret_cast<const tflite::RNNOptionsT *>(value) : nullptr;
2876 }
2883 reinterpret_cast<const tflite::FullyConnectedOptionsT *>(value) : nullptr;
2884 }
2887 reinterpret_cast<tflite::SoftmaxOptionsT *>(value) : nullptr;
2888 }
2891 reinterpret_cast<const tflite::SoftmaxOptionsT *>(value) : nullptr;
2892 }
2899 reinterpret_cast<const tflite::ConcatenationOptionsT *>(value) : nullptr;
2900 }
2903 reinterpret_cast<tflite::AddOptionsT *>(value) : nullptr;
2904 }
2907 reinterpret_cast<const tflite::AddOptionsT *>(value) : nullptr;
2908 }
2911 reinterpret_cast<tflite::L2NormOptionsT *>(value) : nullptr;
2912 }
2915 reinterpret_cast<const tflite::L2NormOptionsT *>(value) : nullptr;
2916 }
2927 reinterpret_cast<tflite::LSTMOptionsT *>(value) : nullptr;
2928 }
2931 reinterpret_cast<const tflite::LSTMOptionsT *>(value) : nullptr;
2932 }
2939 reinterpret_cast<const tflite::ResizeBilinearOptionsT *>(value) : nullptr;
2940 }
2943 reinterpret_cast<tflite::CallOptionsT *>(value) : nullptr;
2944 }
2947 reinterpret_cast<const tflite::CallOptionsT *>(value) : nullptr;
2948 }
2951 reinterpret_cast<tflite::ReshapeOptionsT *>(value) : nullptr;
2952 }
2955 reinterpret_cast<const tflite::ReshapeOptionsT *>(value) : nullptr;
2956 }
2959 reinterpret_cast<tflite::SkipGramOptionsT *>(value) : nullptr;
2960 }
2963 reinterpret_cast<const tflite::SkipGramOptionsT *>(value) : nullptr;
2964 }
2971 reinterpret_cast<const tflite::SpaceToDepthOptionsT *>(value) : nullptr;
2972 }
2983 reinterpret_cast<tflite::MulOptionsT *>(value) : nullptr;
2984 }
2987 reinterpret_cast<const tflite::MulOptionsT *>(value) : nullptr;
2988 }
2991 reinterpret_cast<tflite::PadOptionsT *>(value) : nullptr;
2992 }
2995 reinterpret_cast<const tflite::PadOptionsT *>(value) : nullptr;
2996 }
2999 reinterpret_cast<tflite::GatherOptionsT *>(value) : nullptr;
3000 }
3003 reinterpret_cast<const tflite::GatherOptionsT *>(value) : nullptr;
3004 }
3011 reinterpret_cast<const tflite::BatchToSpaceNDOptionsT *>(value) : nullptr;
3012 }
3019 reinterpret_cast<const tflite::SpaceToBatchNDOptionsT *>(value) : nullptr;
3020 }
3027 reinterpret_cast<const tflite::TransposeOptionsT *>(value) : nullptr;
3028 }
3031 reinterpret_cast<tflite::ReducerOptionsT *>(value) : nullptr;
3032 }
3035 reinterpret_cast<const tflite::ReducerOptionsT *>(value) : nullptr;
3036 }
3039 reinterpret_cast<tflite::SubOptionsT *>(value) : nullptr;
3040 }
3043 reinterpret_cast<const tflite::SubOptionsT *>(value) : nullptr;
3044 }
3047 reinterpret_cast<tflite::DivOptionsT *>(value) : nullptr;
3048 }
3051 reinterpret_cast<const tflite::DivOptionsT *>(value) : nullptr;
3052 }
3055 reinterpret_cast<tflite::SqueezeOptionsT *>(value) : nullptr;
3056 }
3059 reinterpret_cast<const tflite::SqueezeOptionsT *>(value) : nullptr;
3060 }
3067 reinterpret_cast<const tflite::SequenceRNNOptionsT *>(value) : nullptr;
3068 }
3075 reinterpret_cast<const tflite::StridedSliceOptionsT *>(value) : nullptr;
3076 }
3079 reinterpret_cast<tflite::ExpOptionsT *>(value) : nullptr;
3080 }
3083 reinterpret_cast<const tflite::ExpOptionsT *>(value) : nullptr;
3084 }
3087 reinterpret_cast<tflite::TopKV2OptionsT *>(value) : nullptr;
3088 }
3091 reinterpret_cast<const tflite::TopKV2OptionsT *>(value) : nullptr;
3092 }
3095 reinterpret_cast<tflite::SplitOptionsT *>(value) : nullptr;
3096 }
3099 reinterpret_cast<const tflite::SplitOptionsT *>(value) : nullptr;
3100 }
3107 reinterpret_cast<const tflite::LogSoftmaxOptionsT *>(value) : nullptr;
3108 }
3111 reinterpret_cast<tflite::CastOptionsT *>(value) : nullptr;
3112 }
3115 reinterpret_cast<const tflite::CastOptionsT *>(value) : nullptr;
3116 }
3123 reinterpret_cast<const tflite::DequantizeOptionsT *>(value) : nullptr;
3124 }
3131 reinterpret_cast<const tflite::MaximumMinimumOptionsT *>(value) : nullptr;
3132 }
3135 reinterpret_cast<tflite::ArgMaxOptionsT *>(value) : nullptr;
3136 }
3139 reinterpret_cast<const tflite::ArgMaxOptionsT *>(value) : nullptr;
3140 }
3143 reinterpret_cast<tflite::LessOptionsT *>(value) : nullptr;
3144 }
3147 reinterpret_cast<const tflite::LessOptionsT *>(value) : nullptr;
3148 }
3151 reinterpret_cast<tflite::NegOptionsT *>(value) : nullptr;
3152 }
3155 reinterpret_cast<const tflite::NegOptionsT *>(value) : nullptr;
3156 }
3159 reinterpret_cast<tflite::PadV2OptionsT *>(value) : nullptr;
3160 }
3163 reinterpret_cast<const tflite::PadV2OptionsT *>(value) : nullptr;
3164 }
3167 reinterpret_cast<tflite::GreaterOptionsT *>(value) : nullptr;
3168 }
3171 reinterpret_cast<const tflite::GreaterOptionsT *>(value) : nullptr;
3172 }
3179 reinterpret_cast<const tflite::GreaterEqualOptionsT *>(value) : nullptr;
3180 }
3187 reinterpret_cast<const tflite::LessEqualOptionsT *>(value) : nullptr;
3188 }
3191 reinterpret_cast<tflite::SelectOptionsT *>(value) : nullptr;
3192 }
3195 reinterpret_cast<const tflite::SelectOptionsT *>(value) : nullptr;
3196 }
3199 reinterpret_cast<tflite::SliceOptionsT *>(value) : nullptr;
3200 }
3203 reinterpret_cast<const tflite::SliceOptionsT *>(value) : nullptr;
3204 }
3211 reinterpret_cast<const tflite::TransposeConvOptionsT *>(value) : nullptr;
3212 }
3219 reinterpret_cast<const tflite::SparseToDenseOptionsT *>(value) : nullptr;
3220 }
3223 reinterpret_cast<tflite::TileOptionsT *>(value) : nullptr;
3224 }
3227 reinterpret_cast<const tflite::TileOptionsT *>(value) : nullptr;
3228 }
3235 reinterpret_cast<const tflite::ExpandDimsOptionsT *>(value) : nullptr;
3236 }
3239 reinterpret_cast<tflite::EqualOptionsT *>(value) : nullptr;
3240 }
3243 reinterpret_cast<const tflite::EqualOptionsT *>(value) : nullptr;
3244 }
3247 reinterpret_cast<tflite::NotEqualOptionsT *>(value) : nullptr;
3248 }
3251 reinterpret_cast<const tflite::NotEqualOptionsT *>(value) : nullptr;
3252 }
3255 reinterpret_cast<tflite::ShapeOptionsT *>(value) : nullptr;
3256 }
3259 reinterpret_cast<const tflite::ShapeOptionsT *>(value) : nullptr;
3260 }
3263 reinterpret_cast<tflite::PowOptionsT *>(value) : nullptr;
3264 }
3267 reinterpret_cast<const tflite::PowOptionsT *>(value) : nullptr;
3268 }
3271 reinterpret_cast<tflite::ArgMinOptionsT *>(value) : nullptr;
3272 }
3275 reinterpret_cast<const tflite::ArgMinOptionsT *>(value) : nullptr;
3276 }
3283 reinterpret_cast<const tflite::FakeQuantOptionsT *>(value) : nullptr;
3284 }
3287 reinterpret_cast<tflite::PackOptionsT *>(value) : nullptr;
3288 }
3291 reinterpret_cast<const tflite::PackOptionsT *>(value) : nullptr;
3292 }
3299 reinterpret_cast<const tflite::LogicalOrOptionsT *>(value) : nullptr;
3300 }
3303 reinterpret_cast<tflite::OneHotOptionsT *>(value) : nullptr;
3304 }
3307 reinterpret_cast<const tflite::OneHotOptionsT *>(value) : nullptr;
3308 }
3315 reinterpret_cast<const tflite::LogicalAndOptionsT *>(value) : nullptr;
3316 }
3323 reinterpret_cast<const tflite::LogicalNotOptionsT *>(value) : nullptr;
3324 }
3327 reinterpret_cast<tflite::UnpackOptionsT *>(value) : nullptr;
3328 }
3331 reinterpret_cast<const tflite::UnpackOptionsT *>(value) : nullptr;
3332 }
3335 reinterpret_cast<tflite::FloorDivOptionsT *>(value) : nullptr;
3336 }
3339 reinterpret_cast<const tflite::FloorDivOptionsT *>(value) : nullptr;
3340 }
3343 reinterpret_cast<tflite::SquareOptionsT *>(value) : nullptr;
3344 }
3347 reinterpret_cast<const tflite::SquareOptionsT *>(value) : nullptr;
3348 }
3355 reinterpret_cast<const tflite::ZerosLikeOptionsT *>(value) : nullptr;
3356 }
3359 reinterpret_cast<tflite::FillOptionsT *>(value) : nullptr;
3360 }
3363 reinterpret_cast<const tflite::FillOptionsT *>(value) : nullptr;
3364 }
3391 reinterpret_cast<tflite::FloorModOptionsT *>(value) : nullptr;
3392 }
3395 reinterpret_cast<const tflite::FloorModOptionsT *>(value) : nullptr;
3396 }
3399 reinterpret_cast<tflite::RangeOptionsT *>(value) : nullptr;
3400 }
3403 reinterpret_cast<const tflite::RangeOptionsT *>(value) : nullptr;
3404 }
3419 reinterpret_cast<const tflite::LeakyReluOptionsT *>(value) : nullptr;
3420 }
3435 reinterpret_cast<const tflite::MirrorPadOptionsT *>(value) : nullptr;
3436 }
3439 reinterpret_cast<tflite::AbsOptionsT *>(value) : nullptr;
3440 }
3443 reinterpret_cast<const tflite::AbsOptionsT *>(value) : nullptr;
3444 }
3447 reinterpret_cast<tflite::SplitVOptionsT *>(value) : nullptr;
3448 }
3451 reinterpret_cast<const tflite::SplitVOptionsT *>(value) : nullptr;
3452 }
3455 reinterpret_cast<tflite::UniqueOptionsT *>(value) : nullptr;
3456 }
3459 reinterpret_cast<const tflite::UniqueOptionsT *>(value) : nullptr;
3460 }
3467 reinterpret_cast<const tflite::ReverseV2OptionsT *>(value) : nullptr;
3468 }
3471 reinterpret_cast<tflite::AddNOptionsT *>(value) : nullptr;
3472 }
3475 reinterpret_cast<const tflite::AddNOptionsT *>(value) : nullptr;
3476 }
3479 reinterpret_cast<tflite::GatherNdOptionsT *>(value) : nullptr;
3480 }
3483 reinterpret_cast<const tflite::GatherNdOptionsT *>(value) : nullptr;
3484 }
3487 reinterpret_cast<tflite::CosOptionsT *>(value) : nullptr;
3488 }
3491 reinterpret_cast<const tflite::CosOptionsT *>(value) : nullptr;
3492 }
3495 reinterpret_cast<tflite::WhereOptionsT *>(value) : nullptr;
3496 }
3499 reinterpret_cast<const tflite::WhereOptionsT *>(value) : nullptr;
3500 }
3503 reinterpret_cast<tflite::RankOptionsT *>(value) : nullptr;
3504 }
3507 reinterpret_cast<const tflite::RankOptionsT *>(value) : nullptr;
3508 }
3523 reinterpret_cast<const tflite::MatrixDiagOptionsT *>(value) : nullptr;
3524 }
3527 reinterpret_cast<tflite::QuantizeOptionsT *>(value) : nullptr;
3528 }
3531 reinterpret_cast<const tflite::QuantizeOptionsT *>(value) : nullptr;
3532 }
3539 reinterpret_cast<const tflite::MatrixSetDiagOptionsT *>(value) : nullptr;
3540 }
3547 reinterpret_cast<const tflite::HardSwishOptionsT *>(value) : nullptr;
3548 }
3550 return type == BuiltinOptions_IfOptions ?
3551 reinterpret_cast<tflite::IfOptionsT *>(value) : nullptr;
3552 }
3554 return type == BuiltinOptions_IfOptions ?
3555 reinterpret_cast<const tflite::IfOptionsT *>(value) : nullptr;
3556 }
3559 reinterpret_cast<tflite::WhileOptionsT *>(value) : nullptr;
3560 }
3563 reinterpret_cast<const tflite::WhileOptionsT *>(value) : nullptr;
3564 }
3571 reinterpret_cast<const tflite::DepthToSpaceOptionsT *>(value) : nullptr;
3572 }
3595 reinterpret_cast<const tflite::ScatterNdOptionsT *>(value) : nullptr;
3596 }
3599 reinterpret_cast<tflite::SelectV2OptionsT *>(value) : nullptr;
3600 }
3603 reinterpret_cast<const tflite::SelectV2OptionsT *>(value) : nullptr;
3604 }
3607 reinterpret_cast<tflite::DensifyOptionsT *>(value) : nullptr;
3608 }
3611 reinterpret_cast<const tflite::DensifyOptionsT *>(value) : nullptr;
3612 }
3619 reinterpret_cast<const tflite::SegmentSumOptionsT *>(value) : nullptr;
3620 }
3627 reinterpret_cast<const tflite::BatchMatMulOptionsT *>(value) : nullptr;
3628 }
3631 reinterpret_cast<tflite::CumsumOptionsT *>(value) : nullptr;
3632 }
3635 reinterpret_cast<const tflite::CumsumOptionsT *>(value) : nullptr;
3636 }
3639 reinterpret_cast<tflite::CallOnceOptionsT *>(value) : nullptr;
3640 }
3643 reinterpret_cast<const tflite::CallOnceOptionsT *>(value) : nullptr;
3644 }
3651 reinterpret_cast<const tflite::BroadcastToOptionsT *>(value) : nullptr;
3652 }
3655 reinterpret_cast<tflite::Rfft2dOptionsT *>(value) : nullptr;
3656 }
3659 reinterpret_cast<const tflite::Rfft2dOptionsT *>(value) : nullptr;
3660 }
3663 reinterpret_cast<tflite::Conv3DOptionsT *>(value) : nullptr;
3664 }
3667 reinterpret_cast<const tflite::Conv3DOptionsT *>(value) : nullptr;
3668 }
3675 reinterpret_cast<const tflite::HashtableOptionsT *>(value) : nullptr;
3676 }
3683 reinterpret_cast<const tflite::HashtableFindOptionsT *>(value) : nullptr;
3684 }
3699 reinterpret_cast<const tflite::HashtableSizeOptionsT *>(value) : nullptr;
3700 }
3707 reinterpret_cast<const tflite::VarHandleOptionsT *>(value) : nullptr;
3708 }
3715 reinterpret_cast<const tflite::ReadVariableOptionsT *>(value) : nullptr;
3716 }
3723 reinterpret_cast<const tflite::AssignVariableOptionsT *>(value) : nullptr;
3724 }
3727 reinterpret_cast<tflite::RandomOptionsT *>(value) : nullptr;
3728 }
3731 reinterpret_cast<const tflite::RandomOptionsT *>(value) : nullptr;
3732 }
3739 reinterpret_cast<const tflite::BucketizeOptionsT *>(value) : nullptr;
3740 }
3743 reinterpret_cast<tflite::GeluOptionsT *>(value) : nullptr;
3744 }
3747 reinterpret_cast<const tflite::GeluOptionsT *>(value) : nullptr;
3748 }
3791 reinterpret_cast<tflite::ATan2OptionsT *>(value) : nullptr;
3792 }
3795 reinterpret_cast<const tflite::ATan2OptionsT *>(value) : nullptr;
3796 }
3799 reinterpret_cast<tflite::SignOptionsT *>(value) : nullptr;
3800 }
3803 reinterpret_cast<const tflite::SignOptionsT *>(value) : nullptr;
3804 }
3805};
3806
3807bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type);
3808bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
3809
3816
3817inline const Padding (&EnumValuesPadding())[2] {
3818 static const Padding values[] = {
3821 };
3822 return values;
3823}
3824
3825inline const char * const *EnumNamesPadding() {
3826 static const char * const names[3] = {
3827 "SAME",
3828 "VALID",
3829 nullptr
3830 };
3831 return names;
3832}
3833
3834inline const char *EnumNamePadding(Padding e) {
3835 if (flatbuffers::IsOutRange(e, Padding_SAME, Padding_VALID)) return "";
3836 const size_t index = static_cast<size_t>(e);
3837 return EnumNamesPadding()[index];
3838}
3839
3850
3862
3863inline const char * const *EnumNamesActivationFunctionType() {
3864 static const char * const names[7] = {
3865 "NONE",
3866 "RELU",
3867 "RELU_N1_TO_1",
3868 "RELU6",
3869 "TANH",
3870 "SIGN_BIT",
3871 nullptr
3872 };
3873 return names;
3874}
3875
3877 if (flatbuffers::IsOutRange(e, ActivationFunctionType_NONE, ActivationFunctionType_SIGN_BIT)) return "";
3878 const size_t index = static_cast<size_t>(e);
3879 return EnumNamesActivationFunctionType()[index];
3880}
3881
3889
3891 static const LSHProjectionType values[] = {
3895 };
3896 return values;
3897}
3898
3899inline const char * const *EnumNamesLSHProjectionType() {
3900 static const char * const names[4] = {
3901 "UNKNOWN",
3902 "SPARSE",
3903 "DENSE",
3904 nullptr
3905 };
3906 return names;
3907}
3908
3910 if (flatbuffers::IsOutRange(e, LSHProjectionType_UNKNOWN, LSHProjectionType_DENSE)) return "";
3911 const size_t index = static_cast<size_t>(e);
3912 return EnumNamesLSHProjectionType()[index];
3913}
3914
3921
3929
3931 static const char * const names[3] = {
3932 "DEFAULT",
3933 "SHUFFLED4x16INT8",
3934 nullptr
3935 };
3936 return names;
3937}
3938
3941 const size_t index = static_cast<size_t>(e);
3943}
3944
3951
3953 static const LSTMKernelType values[] = {
3956 };
3957 return values;
3958}
3959
3960inline const char * const *EnumNamesLSTMKernelType() {
3961 static const char * const names[3] = {
3962 "FULL",
3963 "BASIC",
3964 nullptr
3965 };
3966 return names;
3967}
3968
3970 if (flatbuffers::IsOutRange(e, LSTMKernelType_FULL, LSTMKernelType_BASIC)) return "";
3971 const size_t index = static_cast<size_t>(e);
3972 return EnumNamesLSTMKernelType()[index];
3973}
3974
3982
3984 static const CombinerType values[] = {
3988 };
3989 return values;
3990}
3991
3992inline const char * const *EnumNamesCombinerType() {
3993 static const char * const names[4] = {
3994 "SUM",
3995 "MEAN",
3996 "SQRTN",
3997 nullptr
3998 };
3999 return names;
4000}
4001
4002inline const char *EnumNameCombinerType(CombinerType e) {
4003 if (flatbuffers::IsOutRange(e, CombinerType_SUM, CombinerType_SQRTN)) return "";
4004 const size_t index = static_cast<size_t>(e);
4005 return EnumNamesCombinerType()[index];
4006}
4007
4014
4016 static const MirrorPadMode values[] = {
4019 };
4020 return values;
4021}
4022
4023inline const char * const *EnumNamesMirrorPadMode() {
4024 static const char * const names[3] = {
4025 "REFLECT",
4026 "SYMMETRIC",
4027 nullptr
4028 };
4029 return names;
4030}
4031
4033 if (flatbuffers::IsOutRange(e, MirrorPadMode_REFLECT, MirrorPadMode_SYMMETRIC)) return "";
4034 const size_t index = static_cast<size_t>(e);
4035 return EnumNamesMirrorPadMode()[index];
4036}
4037
4043
4045 static const CustomOptionsFormat values[] = {
4047 };
4048 return values;
4049}
4050
4051inline const char * const *EnumNamesCustomOptionsFormat() {
4052 static const char * const names[2] = {
4053 "FLEXBUFFERS",
4054 nullptr
4055 };
4056 return names;
4057}
4058
4060 if (flatbuffers::IsOutRange(e, CustomOptionsFormat_FLEXBUFFERS, CustomOptionsFormat_FLEXBUFFERS)) return "";
4061 const size_t index = static_cast<size_t>(e);
4062 return EnumNamesCustomOptionsFormat()[index];
4063}
4064
4065struct CustomQuantizationT : public flatbuffers::NativeTable {
4066 typedef CustomQuantization TableType;
4067 std::vector<uint8_t> custom{};
4068};
4069
4070struct CustomQuantization FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4073 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4074 VT_CUSTOM = 4
4075 };
4077 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM);
4078 }
4079 bool Verify(flatbuffers::Verifier &verifier) const {
4080 return VerifyTableStart(verifier) &&
4081 VerifyOffset(verifier, VT_CUSTOM) &&
4082 verifier.VerifyVector(custom()) &&
4083 verifier.EndTable();
4084 }
4086 void UnPackTo(CustomQuantizationT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4087 static flatbuffers::Offset<CustomQuantization> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4088};
4089
4091 typedef CustomQuantization Table;
4093 flatbuffers::uoffset_t start_;
4094 void add_custom(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom) {
4095 fbb_.AddOffset(CustomQuantization::VT_CUSTOM, custom);
4096 }
4098 : fbb_(_fbb) {
4099 start_ = fbb_.StartTable();
4100 }
4101 flatbuffers::Offset<CustomQuantization> Finish() {
4102 const auto end = fbb_.EndTable(start_);
4103 auto o = flatbuffers::Offset<CustomQuantization>(end);
4104 return o;
4105 }
4106};
4107
4108inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(
4110 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom = 0) {
4112 builder_.add_custom(custom);
4113 return builder_.Finish();
4114}
4115
4116inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantizationDirect(
4118 const std::vector<uint8_t> *custom = nullptr) {
4119 if (custom) { _fbb.ForceVectorAlignment(custom->size(), sizeof(uint8_t), 16); }
4120 auto custom__ = custom ? _fbb.CreateVector<uint8_t>(*custom) : 0;
4122 _fbb,
4123 custom__);
4124}
4125
4126flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4127
4128struct QuantizationParametersT : public flatbuffers::NativeTable {
4129 typedef QuantizationParameters TableType;
4130 std::vector<float> min{};
4131 std::vector<float> max{};
4132 std::vector<float> scale{};
4133 std::vector<int64_t> zero_point{};
4136};
4137
4138struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4141 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4148 VT_QUANTIZED_DIMENSION = 16
4149 };
4151 return GetPointer<const flatbuffers::Vector<float> *>(VT_MIN);
4152 }
4154 return GetPointer<const flatbuffers::Vector<float> *>(VT_MAX);
4155 }
4157 return GetPointer<const flatbuffers::Vector<float> *>(VT_SCALE);
4158 }
4160 return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_ZERO_POINT);
4161 }
4163 return static_cast<tflite::QuantizationDetails>(GetField<uint8_t>(VT_DETAILS_TYPE, 0));
4164 }
4165 const void *details() const {
4166 return GetPointer<const void *>(VT_DETAILS);
4167 }
4168 template<typename T> const T *details_as() const;
4169 const tflite::CustomQuantization *details_as_CustomQuantization() const {
4170 return details_type() == tflite::QuantizationDetails_CustomQuantization ? static_cast<const tflite::CustomQuantization *>(details()) : nullptr;
4171 }
4172 int32_t quantized_dimension() const {
4173 return GetField<int32_t>(VT_QUANTIZED_DIMENSION, 0);
4174 }
4175 bool Verify(flatbuffers::Verifier &verifier) const {
4176 return VerifyTableStart(verifier) &&
4177 VerifyOffset(verifier, VT_MIN) &&
4178 verifier.VerifyVector(min()) &&
4179 VerifyOffset(verifier, VT_MAX) &&
4180 verifier.VerifyVector(max()) &&
4181 VerifyOffset(verifier, VT_SCALE) &&
4182 verifier.VerifyVector(scale()) &&
4183 VerifyOffset(verifier, VT_ZERO_POINT) &&
4184 verifier.VerifyVector(zero_point()) &&
4185 VerifyField<uint8_t>(verifier, VT_DETAILS_TYPE, 1) &&
4186 VerifyOffset(verifier, VT_DETAILS) &&
4187 VerifyQuantizationDetails(verifier, details(), details_type()) &&
4188 VerifyField<int32_t>(verifier, VT_QUANTIZED_DIMENSION, 4) &&
4189 verifier.EndTable();
4190 }
4192 void UnPackTo(QuantizationParametersT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4193 static flatbuffers::Offset<QuantizationParameters> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4194};
4195
4196template<> inline const tflite::CustomQuantization *QuantizationParameters::details_as<tflite::CustomQuantization>() const {
4197 return details_as_CustomQuantization();
4198}
4199
4200struct QuantizationParametersBuilder {
4201 typedef QuantizationParameters Table;
4203 flatbuffers::uoffset_t start_;
4204 void add_min(flatbuffers::Offset<flatbuffers::Vector<float>> min) {
4205 fbb_.AddOffset(QuantizationParameters::VT_MIN, min);
4206 }
4207 void add_max(flatbuffers::Offset<flatbuffers::Vector<float>> max) {
4208 fbb_.AddOffset(QuantizationParameters::VT_MAX, max);
4209 }
4210 void add_scale(flatbuffers::Offset<flatbuffers::Vector<float>> scale) {
4211 fbb_.AddOffset(QuantizationParameters::VT_SCALE, scale);
4212 }
4214 fbb_.AddOffset(QuantizationParameters::VT_ZERO_POINT, zero_point);
4215 }
4217 fbb_.AddElement<uint8_t>(QuantizationParameters::VT_DETAILS_TYPE, static_cast<uint8_t>(details_type), 0);
4218 }
4219 void add_details(flatbuffers::Offset<void> details) {
4220 fbb_.AddOffset(QuantizationParameters::VT_DETAILS, details);
4221 }
4222 void add_quantized_dimension(int32_t quantized_dimension) {
4223 fbb_.AddElement<int32_t>(QuantizationParameters::VT_QUANTIZED_DIMENSION, quantized_dimension, 0);
4224 }
4226 : fbb_(_fbb) {
4227 start_ = fbb_.StartTable();
4228 }
4229 flatbuffers::Offset<QuantizationParameters> Finish() {
4230 const auto end = fbb_.EndTable(start_);
4231 auto o = flatbuffers::Offset<QuantizationParameters>(end);
4232 return o;
4233 }
4234};
4235
4236inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(
4238 flatbuffers::Offset<flatbuffers::Vector<float>> min = 0,
4239 flatbuffers::Offset<flatbuffers::Vector<float>> max = 0,
4240 flatbuffers::Offset<flatbuffers::Vector<float>> scale = 0,
4241 flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point = 0,
4243 flatbuffers::Offset<void> details = 0,
4244 int32_t quantized_dimension = 0) {
4246 builder_.add_quantized_dimension(quantized_dimension);
4247 builder_.add_details(details);
4248 builder_.add_zero_point(zero_point);
4249 builder_.add_scale(scale);
4250 builder_.add_max(max);
4251 builder_.add_min(min);
4252 builder_.add_details_type(details_type);
4253 return builder_.Finish();
4254}
4255
4256inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParametersDirect(
4258 const std::vector<float> *min = nullptr,
4259 const std::vector<float> *max = nullptr,
4260 const std::vector<float> *scale = nullptr,
4261 const std::vector<int64_t> *zero_point = nullptr,
4263 flatbuffers::Offset<void> details = 0,
4264 int32_t quantized_dimension = 0) {
4265 auto min__ = min ? _fbb.CreateVector<float>(*min) : 0;
4266 auto max__ = max ? _fbb.CreateVector<float>(*max) : 0;
4267 auto scale__ = scale ? _fbb.CreateVector<float>(*scale) : 0;
4268 auto zero_point__ = zero_point ? _fbb.CreateVector<int64_t>(*zero_point) : 0;
4270 _fbb,
4271 min__,
4272 max__,
4273 scale__,
4274 zero_point__,
4275 details_type,
4276 details,
4277 quantized_dimension);
4278}
4279
4280flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4281
4282struct Int32VectorT : public flatbuffers::NativeTable {
4283 typedef Int32Vector TableType;
4284 std::vector<int32_t> values{};
4285};
4286
4287struct Int32Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4290 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4291 VT_VALUES = 4
4292 };
4294 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_VALUES);
4295 }
4296 bool Verify(flatbuffers::Verifier &verifier) const {
4297 return VerifyTableStart(verifier) &&
4298 VerifyOffset(verifier, VT_VALUES) &&
4299 verifier.VerifyVector(values()) &&
4300 verifier.EndTable();
4301 }
4302 Int32VectorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4303 void UnPackTo(Int32VectorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4304 static flatbuffers::Offset<Int32Vector> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4305};
4306
4307struct Int32VectorBuilder {
4308 typedef Int32Vector Table;
4310 flatbuffers::uoffset_t start_;
4311 void add_values(flatbuffers::Offset<flatbuffers::Vector<int32_t>> values) {
4312 fbb_.AddOffset(Int32Vector::VT_VALUES, values);
4313 }
4315 : fbb_(_fbb) {
4316 start_ = fbb_.StartTable();
4317 }
4318 flatbuffers::Offset<Int32Vector> Finish() {
4319 const auto end = fbb_.EndTable(start_);
4320 auto o = flatbuffers::Offset<Int32Vector>(end);
4321 return o;
4322 }
4323};
4324
4325inline flatbuffers::Offset<Int32Vector> CreateInt32Vector(
4327 flatbuffers::Offset<flatbuffers::Vector<int32_t>> values = 0) {
4329 builder_.add_values(values);
4330 return builder_.Finish();
4331}
4332
4333inline flatbuffers::Offset<Int32Vector> CreateInt32VectorDirect(
4335 const std::vector<int32_t> *values = nullptr) {
4336 auto values__ = values ? _fbb.CreateVector<int32_t>(*values) : 0;
4338 _fbb,
4339 values__);
4340}
4341
4342flatbuffers::Offset<Int32Vector> CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4343
4344struct Uint16VectorT : public flatbuffers::NativeTable {
4345 typedef Uint16Vector TableType;
4346 std::vector<uint16_t> values{};
4347};
4348
4349struct Uint16Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4352 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4353 VT_VALUES = 4
4354 };
4356 return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_VALUES);
4357 }
4358 bool Verify(flatbuffers::Verifier &verifier) const {
4359 return VerifyTableStart(verifier) &&
4360 VerifyOffset(verifier, VT_VALUES) &&
4361 verifier.VerifyVector(values()) &&
4362 verifier.EndTable();
4363 }
4364 Uint16VectorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4365 void UnPackTo(Uint16VectorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4366 static flatbuffers::Offset<Uint16Vector> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4367};
4368
4369struct Uint16VectorBuilder {
4370 typedef Uint16Vector Table;
4372 flatbuffers::uoffset_t start_;
4373 void add_values(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values) {
4374 fbb_.AddOffset(Uint16Vector::VT_VALUES, values);
4375 }
4377 : fbb_(_fbb) {
4378 start_ = fbb_.StartTable();
4379 }
4380 flatbuffers::Offset<Uint16Vector> Finish() {
4381 const auto end = fbb_.EndTable(start_);
4382 auto o = flatbuffers::Offset<Uint16Vector>(end);
4383 return o;
4384 }
4385};
4386
4387inline flatbuffers::Offset<Uint16Vector> CreateUint16Vector(
4389 flatbuffers::Offset<flatbuffers::Vector<uint16_t>> values = 0) {
4391 builder_.add_values(values);
4392 return builder_.Finish();
4393}
4394
4395inline flatbuffers::Offset<Uint16Vector> CreateUint16VectorDirect(
4397 const std::vector<uint16_t> *values = nullptr) {
4398 if (values) { _fbb.ForceVectorAlignment(values->size(), sizeof(uint16_t), 4); }
4399 auto values__ = values ? _fbb.CreateVector<uint16_t>(*values) : 0;
4401 _fbb,
4402 values__);
4403}
4404
4405flatbuffers::Offset<Uint16Vector> CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4406
4407struct Uint8VectorT : public flatbuffers::NativeTable {
4408 typedef Uint8Vector TableType;
4409 std::vector<uint8_t> values{};
4410};
4411
4412struct Uint8Vector FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4415 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4416 VT_VALUES = 4
4417 };
4419 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_VALUES);
4420 }
4421 bool Verify(flatbuffers::Verifier &verifier) const {
4422 return VerifyTableStart(verifier) &&
4423 VerifyOffset(verifier, VT_VALUES) &&
4424 verifier.VerifyVector(values()) &&
4425 verifier.EndTable();
4426 }
4427 Uint8VectorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4428 void UnPackTo(Uint8VectorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4429 static flatbuffers::Offset<Uint8Vector> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4430};
4431
4432struct Uint8VectorBuilder {
4433 typedef Uint8Vector Table;
4435 flatbuffers::uoffset_t start_;
4436 void add_values(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values) {
4437 fbb_.AddOffset(Uint8Vector::VT_VALUES, values);
4438 }
4440 : fbb_(_fbb) {
4441 start_ = fbb_.StartTable();
4442 }
4443 flatbuffers::Offset<Uint8Vector> Finish() {
4444 const auto end = fbb_.EndTable(start_);
4445 auto o = flatbuffers::Offset<Uint8Vector>(end);
4446 return o;
4447 }
4448};
4449
4450inline flatbuffers::Offset<Uint8Vector> CreateUint8Vector(
4452 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> values = 0) {
4454 builder_.add_values(values);
4455 return builder_.Finish();
4456}
4457
4458inline flatbuffers::Offset<Uint8Vector> CreateUint8VectorDirect(
4460 const std::vector<uint8_t> *values = nullptr) {
4461 if (values) { _fbb.ForceVectorAlignment(values->size(), sizeof(uint8_t), 4); }
4462 auto values__ = values ? _fbb.CreateVector<uint8_t>(*values) : 0;
4464 _fbb,
4465 values__);
4466}
4467
4468flatbuffers::Offset<Uint8Vector> CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4469
4470struct DimensionMetadataT : public flatbuffers::NativeTable {
4471 typedef DimensionMetadata TableType;
4473 int32_t dense_size = 0;
4476};
4477
4478struct DimensionMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4481 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4487 VT_ARRAY_INDICES = 14
4488 };
4490 return static_cast<tflite::DimensionType>(GetField<int8_t>(VT_FORMAT, 0));
4491 }
4492 int32_t dense_size() const {
4493 return GetField<int32_t>(VT_DENSE_SIZE, 0);
4494 }
4496 return static_cast<tflite::SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_SEGMENTS_TYPE, 0));
4497 }
4498 const void *array_segments() const {
4499 return GetPointer<const void *>(VT_ARRAY_SEGMENTS);
4500 }
4501 template<typename T> const T *array_segments_as() const;
4502 const tflite::Int32Vector *array_segments_as_Int32Vector() const {
4503 return array_segments_type() == tflite::SparseIndexVector_Int32Vector ? static_cast<const tflite::Int32Vector *>(array_segments()) : nullptr;
4504 }
4505 const tflite::Uint16Vector *array_segments_as_Uint16Vector() const {
4506 return array_segments_type() == tflite::SparseIndexVector_Uint16Vector ? static_cast<const tflite::Uint16Vector *>(array_segments()) : nullptr;
4507 }
4508 const tflite::Uint8Vector *array_segments_as_Uint8Vector() const {
4509 return array_segments_type() == tflite::SparseIndexVector_Uint8Vector ? static_cast<const tflite::Uint8Vector *>(array_segments()) : nullptr;
4510 }
4512 return static_cast<tflite::SparseIndexVector>(GetField<uint8_t>(VT_ARRAY_INDICES_TYPE, 0));
4513 }
4514 const void *array_indices() const {
4515 return GetPointer<const void *>(VT_ARRAY_INDICES);
4516 }
4517 template<typename T> const T *array_indices_as() const;
4518 const tflite::Int32Vector *array_indices_as_Int32Vector() const {
4519 return array_indices_type() == tflite::SparseIndexVector_Int32Vector ? static_cast<const tflite::Int32Vector *>(array_indices()) : nullptr;
4520 }
4521 const tflite::Uint16Vector *array_indices_as_Uint16Vector() const {
4522 return array_indices_type() == tflite::SparseIndexVector_Uint16Vector ? static_cast<const tflite::Uint16Vector *>(array_indices()) : nullptr;
4523 }
4524 const tflite::Uint8Vector *array_indices_as_Uint8Vector() const {
4525 return array_indices_type() == tflite::SparseIndexVector_Uint8Vector ? static_cast<const tflite::Uint8Vector *>(array_indices()) : nullptr;
4526 }
4527 bool Verify(flatbuffers::Verifier &verifier) const {
4528 return VerifyTableStart(verifier) &&
4529 VerifyField<int8_t>(verifier, VT_FORMAT, 1) &&
4530 VerifyField<int32_t>(verifier, VT_DENSE_SIZE, 4) &&
4531 VerifyField<uint8_t>(verifier, VT_ARRAY_SEGMENTS_TYPE, 1) &&
4532 VerifyOffset(verifier, VT_ARRAY_SEGMENTS) &&
4533 VerifySparseIndexVector(verifier, array_segments(), array_segments_type()) &&
4534 VerifyField<uint8_t>(verifier, VT_ARRAY_INDICES_TYPE, 1) &&
4535 VerifyOffset(verifier, VT_ARRAY_INDICES) &&
4536 VerifySparseIndexVector(verifier, array_indices(), array_indices_type()) &&
4537 verifier.EndTable();
4538 }
4540 void UnPackTo(DimensionMetadataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4541 static flatbuffers::Offset<DimensionMetadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4542};
4543
4544template<> inline const tflite::Int32Vector *DimensionMetadata::array_segments_as<tflite::Int32Vector>() const {
4545 return array_segments_as_Int32Vector();
4546}
4547
4548template<> inline const tflite::Uint16Vector *DimensionMetadata::array_segments_as<tflite::Uint16Vector>() const {
4549 return array_segments_as_Uint16Vector();
4550}
4551
4552template<> inline const tflite::Uint8Vector *DimensionMetadata::array_segments_as<tflite::Uint8Vector>() const {
4553 return array_segments_as_Uint8Vector();
4554}
4555
4556template<> inline const tflite::Int32Vector *DimensionMetadata::array_indices_as<tflite::Int32Vector>() const {
4557 return array_indices_as_Int32Vector();
4558}
4559
4560template<> inline const tflite::Uint16Vector *DimensionMetadata::array_indices_as<tflite::Uint16Vector>() const {
4561 return array_indices_as_Uint16Vector();
4562}
4563
4564template<> inline const tflite::Uint8Vector *DimensionMetadata::array_indices_as<tflite::Uint8Vector>() const {
4565 return array_indices_as_Uint8Vector();
4566}
4567
4568struct DimensionMetadataBuilder {
4569 typedef DimensionMetadata Table;
4571 flatbuffers::uoffset_t start_;
4573 fbb_.AddElement<int8_t>(DimensionMetadata::VT_FORMAT, static_cast<int8_t>(format), 0);
4574 }
4575 void add_dense_size(int32_t dense_size) {
4576 fbb_.AddElement<int32_t>(DimensionMetadata::VT_DENSE_SIZE, dense_size, 0);
4577 }
4579 fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_SEGMENTS_TYPE, static_cast<uint8_t>(array_segments_type), 0);
4580 }
4581 void add_array_segments(flatbuffers::Offset<void> array_segments) {
4582 fbb_.AddOffset(DimensionMetadata::VT_ARRAY_SEGMENTS, array_segments);
4583 }
4585 fbb_.AddElement<uint8_t>(DimensionMetadata::VT_ARRAY_INDICES_TYPE, static_cast<uint8_t>(array_indices_type), 0);
4586 }
4587 void add_array_indices(flatbuffers::Offset<void> array_indices) {
4588 fbb_.AddOffset(DimensionMetadata::VT_ARRAY_INDICES, array_indices);
4589 }
4591 : fbb_(_fbb) {
4592 start_ = fbb_.StartTable();
4593 }
4594 flatbuffers::Offset<DimensionMetadata> Finish() {
4595 const auto end = fbb_.EndTable(start_);
4596 auto o = flatbuffers::Offset<DimensionMetadata>(end);
4597 return o;
4598 }
4599};
4600
4601inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(
4604 int32_t dense_size = 0,
4606 flatbuffers::Offset<void> array_segments = 0,
4608 flatbuffers::Offset<void> array_indices = 0) {
4610 builder_.add_array_indices(array_indices);
4611 builder_.add_array_segments(array_segments);
4612 builder_.add_dense_size(dense_size);
4613 builder_.add_array_indices_type(array_indices_type);
4614 builder_.add_array_segments_type(array_segments_type);
4615 builder_.add_format(format);
4616 return builder_.Finish();
4617}
4618
4619flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4620
4621struct SparsityParametersT : public flatbuffers::NativeTable {
4622 typedef SparsityParameters TableType;
4623 std::vector<int32_t> traversal_order{};
4624 std::vector<int32_t> block_map{};
4625 std::vector<std::unique_ptr<tflite::DimensionMetadataT>> dim_metadata{};
4628 SparsityParametersT(SparsityParametersT&&) FLATBUFFERS_NOEXCEPT = default;
4629 SparsityParametersT &operator=(SparsityParametersT o) FLATBUFFERS_NOEXCEPT;
4630};
4631
4632struct SparsityParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4635 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4638 VT_DIM_METADATA = 8
4639 };
4641 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_TRAVERSAL_ORDER);
4642 }
4644 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_BLOCK_MAP);
4645 }
4647 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>> *>(VT_DIM_METADATA);
4648 }
4649 bool Verify(flatbuffers::Verifier &verifier) const {
4650 return VerifyTableStart(verifier) &&
4651 VerifyOffset(verifier, VT_TRAVERSAL_ORDER) &&
4652 verifier.VerifyVector(traversal_order()) &&
4653 VerifyOffset(verifier, VT_BLOCK_MAP) &&
4654 verifier.VerifyVector(block_map()) &&
4655 VerifyOffset(verifier, VT_DIM_METADATA) &&
4656 verifier.VerifyVector(dim_metadata()) &&
4657 verifier.VerifyVectorOfTables(dim_metadata()) &&
4658 verifier.EndTable();
4659 }
4661 void UnPackTo(SparsityParametersT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4662 static flatbuffers::Offset<SparsityParameters> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4663};
4664
4666 typedef SparsityParameters Table;
4668 flatbuffers::uoffset_t start_;
4669 void add_traversal_order(flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order) {
4670 fbb_.AddOffset(SparsityParameters::VT_TRAVERSAL_ORDER, traversal_order);
4671 }
4672 void add_block_map(flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map) {
4673 fbb_.AddOffset(SparsityParameters::VT_BLOCK_MAP, block_map);
4674 }
4675 void add_dim_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>>> dim_metadata) {
4676 fbb_.AddOffset(SparsityParameters::VT_DIM_METADATA, dim_metadata);
4677 }
4679 : fbb_(_fbb) {
4680 start_ = fbb_.StartTable();
4681 }
4682 flatbuffers::Offset<SparsityParameters> Finish() {
4683 const auto end = fbb_.EndTable(start_);
4684 auto o = flatbuffers::Offset<SparsityParameters>(end);
4685 return o;
4686 }
4687};
4688
4689inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(
4691 flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order = 0,
4692 flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map = 0,
4693 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::DimensionMetadata>>> dim_metadata = 0) {
4695 builder_.add_dim_metadata(dim_metadata);
4696 builder_.add_block_map(block_map);
4697 builder_.add_traversal_order(traversal_order);
4698 return builder_.Finish();
4699}
4700
4701inline flatbuffers::Offset<SparsityParameters> CreateSparsityParametersDirect(
4703 const std::vector<int32_t> *traversal_order = nullptr,
4704 const std::vector<int32_t> *block_map = nullptr,
4705 const std::vector<flatbuffers::Offset<tflite::DimensionMetadata>> *dim_metadata = nullptr) {
4706 auto traversal_order__ = traversal_order ? _fbb.CreateVector<int32_t>(*traversal_order) : 0;
4707 auto block_map__ = block_map ? _fbb.CreateVector<int32_t>(*block_map) : 0;
4708 auto dim_metadata__ = dim_metadata ? _fbb.CreateVector<flatbuffers::Offset<tflite::DimensionMetadata>>(*dim_metadata) : 0;
4710 _fbb,
4711 traversal_order__,
4712 block_map__,
4713 dim_metadata__);
4714}
4715
4716flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4717
4718struct VariantSubTypeT : public flatbuffers::NativeTable {
4719 typedef VariantSubType TableType;
4720 std::vector<int32_t> shape{};
4722 bool has_rank = false;
4723};
4724
4725struct VariantSubType FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4728 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4731 VT_HAS_RANK = 8
4732 };
4734 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
4735 }
4737 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_TYPE, 0));
4738 }
4739 bool has_rank() const {
4740 return GetField<uint8_t>(VT_HAS_RANK, 0) != 0;
4741 }
4742 bool Verify(flatbuffers::Verifier &verifier) const {
4743 return VerifyTableStart(verifier) &&
4744 VerifyOffset(verifier, VT_SHAPE) &&
4745 verifier.VerifyVector(shape()) &&
4746 VerifyField<int8_t>(verifier, VT_TYPE, 1) &&
4747 VerifyField<uint8_t>(verifier, VT_HAS_RANK, 1) &&
4748 verifier.EndTable();
4749 }
4750 VariantSubTypeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4751 void UnPackTo(VariantSubTypeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4752 static flatbuffers::Offset<VariantSubType> Pack(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4753};
4754
4755struct VariantSubTypeBuilder {
4756 typedef VariantSubType Table;
4758 flatbuffers::uoffset_t start_;
4759 void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) {
4760 fbb_.AddOffset(VariantSubType::VT_SHAPE, shape);
4761 }
4763 fbb_.AddElement<int8_t>(VariantSubType::VT_TYPE, static_cast<int8_t>(type), 0);
4764 }
4765 void add_has_rank(bool has_rank) {
4766 fbb_.AddElement<uint8_t>(VariantSubType::VT_HAS_RANK, static_cast<uint8_t>(has_rank), 0);
4767 }
4769 : fbb_(_fbb) {
4770 start_ = fbb_.StartTable();
4771 }
4772 flatbuffers::Offset<VariantSubType> Finish() {
4773 const auto end = fbb_.EndTable(start_);
4774 auto o = flatbuffers::Offset<VariantSubType>(end);
4775 return o;
4776 }
4777};
4778
4779inline flatbuffers::Offset<VariantSubType> CreateVariantSubType(
4781 flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0,
4783 bool has_rank = false) {
4785 builder_.add_shape(shape);
4786 builder_.add_has_rank(has_rank);
4787 builder_.add_type(type);
4788 return builder_.Finish();
4789}
4790
4791inline flatbuffers::Offset<VariantSubType> CreateVariantSubTypeDirect(
4793 const std::vector<int32_t> *shape = nullptr,
4795 bool has_rank = false) {
4796 auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
4798 _fbb,
4799 shape__,
4800 type,
4801 has_rank);
4802}
4803
4804flatbuffers::Offset<VariantSubType> CreateVariantSubType(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4805
4806struct TensorT : public flatbuffers::NativeTable {
4807 typedef Tensor TableType;
4808 std::vector<int32_t> shape{};
4810 uint32_t buffer = 0;
4811 std::string name{};
4812 std::unique_ptr<tflite::QuantizationParametersT> quantization{};
4813 bool is_variable = false;
4814 std::unique_ptr<tflite::SparsityParametersT> sparsity{};
4815 std::vector<int32_t> shape_signature{};
4816 bool has_rank = false;
4817 std::vector<std::unique_ptr<tflite::VariantSubTypeT>> variant_tensors{};
4818 TensorT() = default;
4819 TensorT(const TensorT &o);
4820 TensorT(TensorT&&) FLATBUFFERS_NOEXCEPT = default;
4821 TensorT &operator=(TensorT o) FLATBUFFERS_NOEXCEPT;
4822};
4823
4824struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
4827 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
4828 VT_SHAPE = 4,
4829 VT_TYPE = 6,
4837 VT_VARIANT_TENSORS = 22
4838 };
4840 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
4841 }
4843 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_TYPE, 0));
4844 }
4845 uint32_t buffer() const {
4846 return GetField<uint32_t>(VT_BUFFER, 0);
4847 }
4848 const flatbuffers::String *name() const {
4849 return GetPointer<const flatbuffers::String *>(VT_NAME);
4850 }
4851 const tflite::QuantizationParameters *quantization() const {
4852 return GetPointer<const tflite::QuantizationParameters *>(VT_QUANTIZATION);
4853 }
4854 bool is_variable() const {
4855 return GetField<uint8_t>(VT_IS_VARIABLE, 0) != 0;
4856 }
4857 const tflite::SparsityParameters *sparsity() const {
4858 return GetPointer<const tflite::SparsityParameters *>(VT_SPARSITY);
4859 }
4861 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE_SIGNATURE);
4862 }
4863 bool has_rank() const {
4864 return GetField<uint8_t>(VT_HAS_RANK, 0) != 0;
4865 }
4867 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::VariantSubType>> *>(VT_VARIANT_TENSORS);
4868 }
4869 bool Verify(flatbuffers::Verifier &verifier) const {
4870 return VerifyTableStart(verifier) &&
4871 VerifyOffset(verifier, VT_SHAPE) &&
4872 verifier.VerifyVector(shape()) &&
4873 VerifyField<int8_t>(verifier, VT_TYPE, 1) &&
4874 VerifyField<uint32_t>(verifier, VT_BUFFER, 4) &&
4875 VerifyOffset(verifier, VT_NAME) &&
4876 verifier.VerifyString(name()) &&
4877 VerifyOffset(verifier, VT_QUANTIZATION) &&
4878 verifier.VerifyTable(quantization()) &&
4879 VerifyField<uint8_t>(verifier, VT_IS_VARIABLE, 1) &&
4880 VerifyOffset(verifier, VT_SPARSITY) &&
4881 verifier.VerifyTable(sparsity()) &&
4882 VerifyOffset(verifier, VT_SHAPE_SIGNATURE) &&
4883 verifier.VerifyVector(shape_signature()) &&
4884 VerifyField<uint8_t>(verifier, VT_HAS_RANK, 1) &&
4885 VerifyOffset(verifier, VT_VARIANT_TENSORS) &&
4886 verifier.VerifyVector(variant_tensors()) &&
4887 verifier.VerifyVectorOfTables(variant_tensors()) &&
4888 verifier.EndTable();
4889 }
4890 TensorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4891 void UnPackTo(TensorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
4892 static flatbuffers::Offset<Tensor> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4893};
4894
4895struct TensorBuilder {
4896 typedef Tensor Table;
4898 flatbuffers::uoffset_t start_;
4899 void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) {
4900 fbb_.AddOffset(Tensor::VT_SHAPE, shape);
4901 }
4903 fbb_.AddElement<int8_t>(Tensor::VT_TYPE, static_cast<int8_t>(type), 0);
4904 }
4905 void add_buffer(uint32_t buffer) {
4906 fbb_.AddElement<uint32_t>(Tensor::VT_BUFFER, buffer, 0);
4907 }
4908 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
4909 fbb_.AddOffset(Tensor::VT_NAME, name);
4910 }
4911 void add_quantization(flatbuffers::Offset<tflite::QuantizationParameters> quantization) {
4912 fbb_.AddOffset(Tensor::VT_QUANTIZATION, quantization);
4913 }
4914 void add_is_variable(bool is_variable) {
4915 fbb_.AddElement<uint8_t>(Tensor::VT_IS_VARIABLE, static_cast<uint8_t>(is_variable), 0);
4916 }
4917 void add_sparsity(flatbuffers::Offset<tflite::SparsityParameters> sparsity) {
4918 fbb_.AddOffset(Tensor::VT_SPARSITY, sparsity);
4919 }
4920 void add_shape_signature(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature) {
4921 fbb_.AddOffset(Tensor::VT_SHAPE_SIGNATURE, shape_signature);
4922 }
4923 void add_has_rank(bool has_rank) {
4924 fbb_.AddElement<uint8_t>(Tensor::VT_HAS_RANK, static_cast<uint8_t>(has_rank), 0);
4925 }
4926 void add_variant_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::VariantSubType>>> variant_tensors) {
4927 fbb_.AddOffset(Tensor::VT_VARIANT_TENSORS, variant_tensors);
4928 }
4930 : fbb_(_fbb) {
4931 start_ = fbb_.StartTable();
4932 }
4933 flatbuffers::Offset<Tensor> Finish() {
4934 const auto end = fbb_.EndTable(start_);
4935 auto o = flatbuffers::Offset<Tensor>(end);
4936 return o;
4937 }
4938};
4939
4940inline flatbuffers::Offset<Tensor> CreateTensor(
4942 flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0,
4944 uint32_t buffer = 0,
4945 flatbuffers::Offset<flatbuffers::String> name = 0,
4946 flatbuffers::Offset<tflite::QuantizationParameters> quantization = 0,
4947 bool is_variable = false,
4948 flatbuffers::Offset<tflite::SparsityParameters> sparsity = 0,
4949 flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape_signature = 0,
4950 bool has_rank = false,
4951 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::VariantSubType>>> variant_tensors = 0) {
4952 TensorBuilder builder_(_fbb);
4953 builder_.add_variant_tensors(variant_tensors);
4954 builder_.add_shape_signature(shape_signature);
4955 builder_.add_sparsity(sparsity);
4956 builder_.add_quantization(quantization);
4957 builder_.add_name(name);
4958 builder_.add_buffer(buffer);
4959 builder_.add_shape(shape);
4960 builder_.add_has_rank(has_rank);
4961 builder_.add_is_variable(is_variable);
4962 builder_.add_type(type);
4963 return builder_.Finish();
4964}
4965
4966inline flatbuffers::Offset<Tensor> CreateTensorDirect(
4968 const std::vector<int32_t> *shape = nullptr,
4970 uint32_t buffer = 0,
4971 const char *name = nullptr,
4972 flatbuffers::Offset<tflite::QuantizationParameters> quantization = 0,
4973 bool is_variable = false,
4974 flatbuffers::Offset<tflite::SparsityParameters> sparsity = 0,
4975 const std::vector<int32_t> *shape_signature = nullptr,
4976 bool has_rank = false,
4977 const std::vector<flatbuffers::Offset<tflite::VariantSubType>> *variant_tensors = nullptr) {
4978 auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
4979 auto name__ = name ? _fbb.CreateString(name) : 0;
4980 auto shape_signature__ = shape_signature ? _fbb.CreateVector<int32_t>(*shape_signature) : 0;
4981 auto variant_tensors__ = variant_tensors ? _fbb.CreateVector<flatbuffers::Offset<tflite::VariantSubType>>(*variant_tensors) : 0;
4982 return tflite::CreateTensor(
4983 _fbb,
4984 shape__,
4985 type,
4986 buffer,
4987 name__,
4989 is_variable,
4990 sparsity,
4991 shape_signature__,
4992 has_rank,
4993 variant_tensors__);
4994}
4995
4996flatbuffers::Offset<Tensor> CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
4997
4998struct Conv2DOptionsT : public flatbuffers::NativeTable {
4999 typedef Conv2DOptions TableType;
5001 int32_t stride_w = 0;
5002 int32_t stride_h = 0;
5004 int32_t dilation_w_factor = 1;
5005 int32_t dilation_h_factor = 1;
5006};
5007
5008struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5011 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5018 };
5020 return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
5021 }
5022 int32_t stride_w() const {
5023 return GetField<int32_t>(VT_STRIDE_W, 0);
5024 }
5025 int32_t stride_h() const {
5026 return GetField<int32_t>(VT_STRIDE_H, 0);
5027 }
5031 int32_t dilation_w_factor() const {
5032 return GetField<int32_t>(VT_DILATION_W_FACTOR, 1);
5033 }
5034 int32_t dilation_h_factor() const {
5035 return GetField<int32_t>(VT_DILATION_H_FACTOR, 1);
5036 }
5037 bool Verify(flatbuffers::Verifier &verifier) const {
5038 return VerifyTableStart(verifier) &&
5039 VerifyField<int8_t>(verifier, VT_PADDING, 1) &&
5040 VerifyField<int32_t>(verifier, VT_STRIDE_W, 4) &&
5041 VerifyField<int32_t>(verifier, VT_STRIDE_H, 4) &&
5042 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
5043 VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR, 4) &&
5044 VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR, 4) &&
5045 verifier.EndTable();
5046 }
5047 Conv2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5048 void UnPackTo(Conv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5049 static flatbuffers::Offset<Conv2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5050};
5051
5052struct Conv2DOptionsBuilder {
5053 typedef Conv2DOptions Table;
5055 flatbuffers::uoffset_t start_;
5057 fbb_.AddElement<int8_t>(Conv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
5058 }
5059 void add_stride_w(int32_t stride_w) {
5060 fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_W, stride_w, 0);
5061 }
5062 void add_stride_h(int32_t stride_h) {
5063 fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_H, stride_h, 0);
5064 }
5066 fbb_.AddElement<int8_t>(Conv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5067 }
5068 void add_dilation_w_factor(int32_t dilation_w_factor) {
5069 fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
5070 }
5071 void add_dilation_h_factor(int32_t dilation_h_factor) {
5072 fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
5073 }
5075 : fbb_(_fbb) {
5076 start_ = fbb_.StartTable();
5077 }
5078 flatbuffers::Offset<Conv2DOptions> Finish() {
5079 const auto end = fbb_.EndTable(start_);
5080 auto o = flatbuffers::Offset<Conv2DOptions>(end);
5081 return o;
5082 }
5083};
5084
5085inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(
5088 int32_t stride_w = 0,
5089 int32_t stride_h = 0,
5091 int32_t dilation_w_factor = 1,
5092 int32_t dilation_h_factor = 1) {
5094 builder_.add_dilation_h_factor(dilation_h_factor);
5095 builder_.add_dilation_w_factor(dilation_w_factor);
5096 builder_.add_stride_h(stride_h);
5097 builder_.add_stride_w(stride_w);
5098 builder_.add_fused_activation_function(fused_activation_function);
5099 builder_.add_padding(padding);
5100 return builder_.Finish();
5101}
5102
5103flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5104
5105struct Conv3DOptionsT : public flatbuffers::NativeTable {
5106 typedef Conv3DOptions TableType;
5108 int32_t stride_d = 0;
5109 int32_t stride_w = 0;
5110 int32_t stride_h = 0;
5112 int32_t dilation_d_factor = 1;
5113 int32_t dilation_w_factor = 1;
5114 int32_t dilation_h_factor = 1;
5115};
5116
5117struct Conv3DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5120 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5121 VT_PADDING = 4,
5123 VT_STRIDE_W = 8,
5124 VT_STRIDE_H = 10,
5129 };
5131 return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
5132 }
5133 int32_t stride_d() const {
5134 return GetField<int32_t>(VT_STRIDE_D, 0);
5135 }
5136 int32_t stride_w() const {
5137 return GetField<int32_t>(VT_STRIDE_W, 0);
5138 }
5139 int32_t stride_h() const {
5140 return GetField<int32_t>(VT_STRIDE_H, 0);
5141 }
5145 int32_t dilation_d_factor() const {
5146 return GetField<int32_t>(VT_DILATION_D_FACTOR, 1);
5147 }
5148 int32_t dilation_w_factor() const {
5149 return GetField<int32_t>(VT_DILATION_W_FACTOR, 1);
5150 }
5151 int32_t dilation_h_factor() const {
5152 return GetField<int32_t>(VT_DILATION_H_FACTOR, 1);
5153 }
5154 bool Verify(flatbuffers::Verifier &verifier) const {
5155 return VerifyTableStart(verifier) &&
5156 VerifyField<int8_t>(verifier, VT_PADDING, 1) &&
5157 VerifyField<int32_t>(verifier, VT_STRIDE_D, 4) &&
5158 VerifyField<int32_t>(verifier, VT_STRIDE_W, 4) &&
5159 VerifyField<int32_t>(verifier, VT_STRIDE_H, 4) &&
5160 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
5161 VerifyField<int32_t>(verifier, VT_DILATION_D_FACTOR, 4) &&
5162 VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR, 4) &&
5163 VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR, 4) &&
5164 verifier.EndTable();
5165 }
5166 Conv3DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5167 void UnPackTo(Conv3DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5168 static flatbuffers::Offset<Conv3DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5169};
5170
5171struct Conv3DOptionsBuilder {
5172 typedef Conv3DOptions Table;
5174 flatbuffers::uoffset_t start_;
5176 fbb_.AddElement<int8_t>(Conv3DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
5177 }
5178 void add_stride_d(int32_t stride_d) {
5179 fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_D, stride_d, 0);
5180 }
5181 void add_stride_w(int32_t stride_w) {
5182 fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_W, stride_w, 0);
5183 }
5184 void add_stride_h(int32_t stride_h) {
5185 fbb_.AddElement<int32_t>(Conv3DOptions::VT_STRIDE_H, stride_h, 0);
5186 }
5188 fbb_.AddElement<int8_t>(Conv3DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5189 }
5190 void add_dilation_d_factor(int32_t dilation_d_factor) {
5191 fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_D_FACTOR, dilation_d_factor, 1);
5192 }
5193 void add_dilation_w_factor(int32_t dilation_w_factor) {
5194 fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
5195 }
5196 void add_dilation_h_factor(int32_t dilation_h_factor) {
5197 fbb_.AddElement<int32_t>(Conv3DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
5198 }
5200 : fbb_(_fbb) {
5201 start_ = fbb_.StartTable();
5202 }
5203 flatbuffers::Offset<Conv3DOptions> Finish() {
5204 const auto end = fbb_.EndTable(start_);
5205 auto o = flatbuffers::Offset<Conv3DOptions>(end);
5206 return o;
5207 }
5208};
5209
5210inline flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(
5213 int32_t stride_d = 0,
5214 int32_t stride_w = 0,
5215 int32_t stride_h = 0,
5217 int32_t dilation_d_factor = 1,
5218 int32_t dilation_w_factor = 1,
5219 int32_t dilation_h_factor = 1) {
5221 builder_.add_dilation_h_factor(dilation_h_factor);
5222 builder_.add_dilation_w_factor(dilation_w_factor);
5223 builder_.add_dilation_d_factor(dilation_d_factor);
5224 builder_.add_stride_h(stride_h);
5225 builder_.add_stride_w(stride_w);
5226 builder_.add_stride_d(stride_d);
5227 builder_.add_fused_activation_function(fused_activation_function);
5228 builder_.add_padding(padding);
5229 return builder_.Finish();
5230}
5231
5232flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5233
5234struct Pool2DOptionsT : public flatbuffers::NativeTable {
5235 typedef Pool2DOptions TableType;
5237 int32_t stride_w = 0;
5238 int32_t stride_h = 0;
5239 int32_t filter_width = 0;
5240 int32_t filter_height = 0;
5242};
5243
5244struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5247 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5248 VT_PADDING = 4,
5249 VT_STRIDE_W = 6,
5250 VT_STRIDE_H = 8,
5254 };
5256 return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
5257 }
5258 int32_t stride_w() const {
5259 return GetField<int32_t>(VT_STRIDE_W, 0);
5260 }
5261 int32_t stride_h() const {
5262 return GetField<int32_t>(VT_STRIDE_H, 0);
5263 }
5264 int32_t filter_width() const {
5265 return GetField<int32_t>(VT_FILTER_WIDTH, 0);
5266 }
5267 int32_t filter_height() const {
5268 return GetField<int32_t>(VT_FILTER_HEIGHT, 0);
5269 }
5273 bool Verify(flatbuffers::Verifier &verifier) const {
5274 return VerifyTableStart(verifier) &&
5275 VerifyField<int8_t>(verifier, VT_PADDING, 1) &&
5276 VerifyField<int32_t>(verifier, VT_STRIDE_W, 4) &&
5277 VerifyField<int32_t>(verifier, VT_STRIDE_H, 4) &&
5278 VerifyField<int32_t>(verifier, VT_FILTER_WIDTH, 4) &&
5279 VerifyField<int32_t>(verifier, VT_FILTER_HEIGHT, 4) &&
5280 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
5281 verifier.EndTable();
5282 }
5283 Pool2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5284 void UnPackTo(Pool2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5285 static flatbuffers::Offset<Pool2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5286};
5287
5288struct Pool2DOptionsBuilder {
5289 typedef Pool2DOptions Table;
5291 flatbuffers::uoffset_t start_;
5293 fbb_.AddElement<int8_t>(Pool2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
5294 }
5295 void add_stride_w(int32_t stride_w) {
5296 fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_W, stride_w, 0);
5297 }
5298 void add_stride_h(int32_t stride_h) {
5299 fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_H, stride_h, 0);
5300 }
5302 fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_WIDTH, filter_width, 0);
5303 }
5305 fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_HEIGHT, filter_height, 0);
5306 }
5308 fbb_.AddElement<int8_t>(Pool2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5309 }
5311 : fbb_(_fbb) {
5312 start_ = fbb_.StartTable();
5313 }
5314 flatbuffers::Offset<Pool2DOptions> Finish() {
5315 const auto end = fbb_.EndTable(start_);
5316 auto o = flatbuffers::Offset<Pool2DOptions>(end);
5317 return o;
5318 }
5319};
5320
5321inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(
5324 int32_t stride_w = 0,
5325 int32_t stride_h = 0,
5326 int32_t filter_width = 0,
5327 int32_t filter_height = 0,
5330 builder_.add_filter_height(filter_height);
5331 builder_.add_filter_width(filter_width);
5332 builder_.add_stride_h(stride_h);
5333 builder_.add_stride_w(stride_w);
5334 builder_.add_fused_activation_function(fused_activation_function);
5335 builder_.add_padding(padding);
5336 return builder_.Finish();
5337}
5338
5339flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5340
5341struct DepthwiseConv2DOptionsT : public flatbuffers::NativeTable {
5342 typedef DepthwiseConv2DOptions TableType;
5344 int32_t stride_w = 0;
5345 int32_t stride_h = 0;
5346 int32_t depth_multiplier = 0;
5348 int32_t dilation_w_factor = 1;
5349 int32_t dilation_h_factor = 1;
5350};
5351
5352struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5355 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5356 VT_PADDING = 4,
5357 VT_STRIDE_W = 6,
5358 VT_STRIDE_H = 8,
5363 };
5365 return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
5366 }
5367 int32_t stride_w() const {
5368 return GetField<int32_t>(VT_STRIDE_W, 0);
5369 }
5370 int32_t stride_h() const {
5371 return GetField<int32_t>(VT_STRIDE_H, 0);
5372 }
5373 int32_t depth_multiplier() const {
5374 return GetField<int32_t>(VT_DEPTH_MULTIPLIER, 0);
5375 }
5379 int32_t dilation_w_factor() const {
5380 return GetField<int32_t>(VT_DILATION_W_FACTOR, 1);
5381 }
5382 int32_t dilation_h_factor() const {
5383 return GetField<int32_t>(VT_DILATION_H_FACTOR, 1);
5384 }
5385 bool Verify(flatbuffers::Verifier &verifier) const {
5386 return VerifyTableStart(verifier) &&
5387 VerifyField<int8_t>(verifier, VT_PADDING, 1) &&
5388 VerifyField<int32_t>(verifier, VT_STRIDE_W, 4) &&
5389 VerifyField<int32_t>(verifier, VT_STRIDE_H, 4) &&
5390 VerifyField<int32_t>(verifier, VT_DEPTH_MULTIPLIER, 4) &&
5391 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
5392 VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR, 4) &&
5393 VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR, 4) &&
5394 verifier.EndTable();
5395 }
5397 void UnPackTo(DepthwiseConv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5398 static flatbuffers::Offset<DepthwiseConv2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5399};
5400
5402 typedef DepthwiseConv2DOptions Table;
5404 flatbuffers::uoffset_t start_;
5406 fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
5407 }
5408 void add_stride_w(int32_t stride_w) {
5409 fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_W, stride_w, 0);
5410 }
5411 void add_stride_h(int32_t stride_h) {
5412 fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_H, stride_h, 0);
5413 }
5414 void add_depth_multiplier(int32_t depth_multiplier) {
5415 fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DEPTH_MULTIPLIER, depth_multiplier, 0);
5416 }
5418 fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5419 }
5420 void add_dilation_w_factor(int32_t dilation_w_factor) {
5421 fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1);
5422 }
5423 void add_dilation_h_factor(int32_t dilation_h_factor) {
5424 fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1);
5425 }
5427 : fbb_(_fbb) {
5428 start_ = fbb_.StartTable();
5429 }
5430 flatbuffers::Offset<DepthwiseConv2DOptions> Finish() {
5431 const auto end = fbb_.EndTable(start_);
5432 auto o = flatbuffers::Offset<DepthwiseConv2DOptions>(end);
5433 return o;
5434 }
5435};
5436
5437inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(
5440 int32_t stride_w = 0,
5441 int32_t stride_h = 0,
5442 int32_t depth_multiplier = 0,
5444 int32_t dilation_w_factor = 1,
5445 int32_t dilation_h_factor = 1) {
5447 builder_.add_dilation_h_factor(dilation_h_factor);
5448 builder_.add_dilation_w_factor(dilation_w_factor);
5449 builder_.add_depth_multiplier(depth_multiplier);
5450 builder_.add_stride_h(stride_h);
5451 builder_.add_stride_w(stride_w);
5452 builder_.add_fused_activation_function(fused_activation_function);
5453 builder_.add_padding(padding);
5454 return builder_.Finish();
5455}
5456
5457flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5458
5459struct ConcatEmbeddingsOptionsT : public flatbuffers::NativeTable {
5460 typedef ConcatEmbeddingsOptions TableType;
5461 int32_t num_channels = 0;
5462 std::vector<int32_t> num_columns_per_channel{};
5463 std::vector<int32_t> embedding_dim_per_channel{};
5464};
5465
5466struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5469 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5472 VT_EMBEDDING_DIM_PER_CHANNEL = 8
5473 };
5474 int32_t num_channels() const {
5475 return GetField<int32_t>(VT_NUM_CHANNELS, 0);
5476 }
5478 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NUM_COLUMNS_PER_CHANNEL);
5479 }
5481 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_EMBEDDING_DIM_PER_CHANNEL);
5482 }
5483 bool Verify(flatbuffers::Verifier &verifier) const {
5484 return VerifyTableStart(verifier) &&
5485 VerifyField<int32_t>(verifier, VT_NUM_CHANNELS, 4) &&
5486 VerifyOffset(verifier, VT_NUM_COLUMNS_PER_CHANNEL) &&
5487 verifier.VerifyVector(num_columns_per_channel()) &&
5488 VerifyOffset(verifier, VT_EMBEDDING_DIM_PER_CHANNEL) &&
5489 verifier.VerifyVector(embedding_dim_per_channel()) &&
5490 verifier.EndTable();
5491 }
5493 void UnPackTo(ConcatEmbeddingsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5494 static flatbuffers::Offset<ConcatEmbeddingsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5495};
5496
5498 typedef ConcatEmbeddingsOptions Table;
5500 flatbuffers::uoffset_t start_;
5502 fbb_.AddElement<int32_t>(ConcatEmbeddingsOptions::VT_NUM_CHANNELS, num_channels, 0);
5503 }
5504 void add_num_columns_per_channel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel) {
5505 fbb_.AddOffset(ConcatEmbeddingsOptions::VT_NUM_COLUMNS_PER_CHANNEL, num_columns_per_channel);
5506 }
5507 void add_embedding_dim_per_channel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel) {
5508 fbb_.AddOffset(ConcatEmbeddingsOptions::VT_EMBEDDING_DIM_PER_CHANNEL, embedding_dim_per_channel);
5509 }
5511 : fbb_(_fbb) {
5512 start_ = fbb_.StartTable();
5513 }
5514 flatbuffers::Offset<ConcatEmbeddingsOptions> Finish() {
5515 const auto end = fbb_.EndTable(start_);
5516 auto o = flatbuffers::Offset<ConcatEmbeddingsOptions>(end);
5517 return o;
5518 }
5519};
5520
5521inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(
5523 int32_t num_channels = 0,
5524 flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel = 0,
5525 flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel = 0) {
5527 builder_.add_embedding_dim_per_channel(embedding_dim_per_channel);
5528 builder_.add_num_columns_per_channel(num_columns_per_channel);
5529 builder_.add_num_channels(num_channels);
5530 return builder_.Finish();
5531}
5532
5533inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptionsDirect(
5535 int32_t num_channels = 0,
5536 const std::vector<int32_t> *num_columns_per_channel = nullptr,
5537 const std::vector<int32_t> *embedding_dim_per_channel = nullptr) {
5538 auto num_columns_per_channel__ = num_columns_per_channel ? _fbb.CreateVector<int32_t>(*num_columns_per_channel) : 0;
5539 auto embedding_dim_per_channel__ = embedding_dim_per_channel ? _fbb.CreateVector<int32_t>(*embedding_dim_per_channel) : 0;
5541 _fbb,
5543 num_columns_per_channel__,
5544 embedding_dim_per_channel__);
5545}
5546
5547flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5548
5549struct LSHProjectionOptionsT : public flatbuffers::NativeTable {
5550 typedef LSHProjectionOptions TableType;
5552};
5553
5554struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5557 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5558 VT_TYPE = 4
5559 };
5561 return static_cast<tflite::LSHProjectionType>(GetField<int8_t>(VT_TYPE, 0));
5562 }
5563 bool Verify(flatbuffers::Verifier &verifier) const {
5564 return VerifyTableStart(verifier) &&
5565 VerifyField<int8_t>(verifier, VT_TYPE, 1) &&
5566 verifier.EndTable();
5567 }
5569 void UnPackTo(LSHProjectionOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5570 static flatbuffers::Offset<LSHProjectionOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5571};
5572
5574 typedef LSHProjectionOptions Table;
5576 flatbuffers::uoffset_t start_;
5578 fbb_.AddElement<int8_t>(LSHProjectionOptions::VT_TYPE, static_cast<int8_t>(type), 0);
5579 }
5581 : fbb_(_fbb) {
5582 start_ = fbb_.StartTable();
5583 }
5584 flatbuffers::Offset<LSHProjectionOptions> Finish() {
5585 const auto end = fbb_.EndTable(start_);
5586 auto o = flatbuffers::Offset<LSHProjectionOptions>(end);
5587 return o;
5588 }
5589};
5590
5591inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(
5595 builder_.add_type(type);
5596 return builder_.Finish();
5597}
5598
5599flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5600
5601struct SVDFOptionsT : public flatbuffers::NativeTable {
5602 typedef SVDFOptions TableType;
5603 int32_t rank = 0;
5605 bool asymmetric_quantize_inputs = false;
5606};
5607
5608struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5611 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5615 };
5616 int32_t rank() const {
5617 return GetField<int32_t>(VT_RANK, 0);
5618 }
5623 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
5624 }
5625 bool Verify(flatbuffers::Verifier &verifier) const {
5626 return VerifyTableStart(verifier) &&
5627 VerifyField<int32_t>(verifier, VT_RANK, 4) &&
5628 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
5629 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
5630 verifier.EndTable();
5631 }
5632 SVDFOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5633 void UnPackTo(SVDFOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5634 static flatbuffers::Offset<SVDFOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5635};
5636
5637struct SVDFOptionsBuilder {
5638 typedef SVDFOptions Table;
5640 flatbuffers::uoffset_t start_;
5641 void add_rank(int32_t rank) {
5642 fbb_.AddElement<int32_t>(SVDFOptions::VT_RANK, rank, 0);
5643 }
5645 fbb_.AddElement<int8_t>(SVDFOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5646 }
5647 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5648 fbb_.AddElement<uint8_t>(SVDFOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
5649 }
5651 : fbb_(_fbb) {
5652 start_ = fbb_.StartTable();
5653 }
5654 flatbuffers::Offset<SVDFOptions> Finish() {
5655 const auto end = fbb_.EndTable(start_);
5656 auto o = flatbuffers::Offset<SVDFOptions>(end);
5657 return o;
5658 }
5659};
5660
5661inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(
5663 int32_t rank = 0,
5665 bool asymmetric_quantize_inputs = false) {
5667 builder_.add_rank(rank);
5668 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5669 builder_.add_fused_activation_function(fused_activation_function);
5670 return builder_.Finish();
5671}
5672
5673flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5674
5675struct RNNOptionsT : public flatbuffers::NativeTable {
5676 typedef RNNOptions TableType;
5678 bool asymmetric_quantize_inputs = false;
5679};
5680
5681struct RNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5684 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5687 };
5692 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
5693 }
5694 bool Verify(flatbuffers::Verifier &verifier) const {
5695 return VerifyTableStart(verifier) &&
5696 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
5697 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
5698 verifier.EndTable();
5699 }
5700 RNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5701 void UnPackTo(RNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5702 static flatbuffers::Offset<RNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5703};
5704
5705struct RNNOptionsBuilder {
5706 typedef RNNOptions Table;
5708 flatbuffers::uoffset_t start_;
5710 fbb_.AddElement<int8_t>(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5711 }
5712 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5713 fbb_.AddElement<uint8_t>(RNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
5714 }
5716 : fbb_(_fbb) {
5717 start_ = fbb_.StartTable();
5718 }
5719 flatbuffers::Offset<RNNOptions> Finish() {
5720 const auto end = fbb_.EndTable(start_);
5721 auto o = flatbuffers::Offset<RNNOptions>(end);
5722 return o;
5723 }
5724};
5725
5726inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(
5729 bool asymmetric_quantize_inputs = false) {
5731 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5732 builder_.add_fused_activation_function(fused_activation_function);
5733 return builder_.Finish();
5734}
5735
5736flatbuffers::Offset<RNNOptions> CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5737
5738struct SequenceRNNOptionsT : public flatbuffers::NativeTable {
5739 typedef SequenceRNNOptions TableType;
5740 bool time_major = false;
5742 bool asymmetric_quantize_inputs = false;
5743};
5744
5745struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5748 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5752 };
5753 bool time_major() const {
5754 return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0;
5755 }
5760 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
5761 }
5762 bool Verify(flatbuffers::Verifier &verifier) const {
5763 return VerifyTableStart(verifier) &&
5764 VerifyField<uint8_t>(verifier, VT_TIME_MAJOR, 1) &&
5765 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
5766 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
5767 verifier.EndTable();
5768 }
5770 void UnPackTo(SequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5771 static flatbuffers::Offset<SequenceRNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5772};
5773
5775 typedef SequenceRNNOptions Table;
5777 flatbuffers::uoffset_t start_;
5778 void add_time_major(bool time_major) {
5779 fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
5780 }
5782 fbb_.AddElement<int8_t>(SequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5783 }
5784 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5785 fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
5786 }
5788 : fbb_(_fbb) {
5789 start_ = fbb_.StartTable();
5790 }
5791 flatbuffers::Offset<SequenceRNNOptions> Finish() {
5792 const auto end = fbb_.EndTable(start_);
5793 auto o = flatbuffers::Offset<SequenceRNNOptions>(end);
5794 return o;
5795 }
5796};
5797
5798inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(
5800 bool time_major = false,
5802 bool asymmetric_quantize_inputs = false) {
5804 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5805 builder_.add_fused_activation_function(fused_activation_function);
5806 builder_.add_time_major(time_major);
5807 return builder_.Finish();
5808}
5809
5810flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5811
5812struct BidirectionalSequenceRNNOptionsT : public flatbuffers::NativeTable {
5813 typedef BidirectionalSequenceRNNOptions TableType;
5814 bool time_major = false;
5816 bool merge_outputs = false;
5817 bool asymmetric_quantize_inputs = false;
5818};
5819
5820struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5823 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5824 VT_TIME_MAJOR = 4,
5828 };
5829 bool time_major() const {
5830 return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0;
5831 }
5835 bool merge_outputs() const {
5836 return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0;
5837 }
5839 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
5840 }
5841 bool Verify(flatbuffers::Verifier &verifier) const {
5842 return VerifyTableStart(verifier) &&
5843 VerifyField<uint8_t>(verifier, VT_TIME_MAJOR, 1) &&
5844 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
5845 VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS, 1) &&
5846 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
5847 verifier.EndTable();
5848 }
5851 static flatbuffers::Offset<BidirectionalSequenceRNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5852};
5853
5855 typedef BidirectionalSequenceRNNOptions Table;
5857 flatbuffers::uoffset_t start_;
5858 void add_time_major(bool time_major) {
5859 fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
5860 }
5862 fbb_.AddElement<int8_t>(BidirectionalSequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5863 }
5864 void add_merge_outputs(bool merge_outputs) {
5865 fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_MERGE_OUTPUTS, static_cast<uint8_t>(merge_outputs), 0);
5866 }
5867 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5868 fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
5869 }
5871 : fbb_(_fbb) {
5872 start_ = fbb_.StartTable();
5873 }
5874 flatbuffers::Offset<BidirectionalSequenceRNNOptions> Finish() {
5875 const auto end = fbb_.EndTable(start_);
5876 auto o = flatbuffers::Offset<BidirectionalSequenceRNNOptions>(end);
5877 return o;
5878 }
5879};
5880
5881inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(
5883 bool time_major = false,
5885 bool merge_outputs = false,
5886 bool asymmetric_quantize_inputs = false) {
5888 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5889 builder_.add_merge_outputs(merge_outputs);
5890 builder_.add_fused_activation_function(fused_activation_function);
5891 builder_.add_time_major(time_major);
5892 return builder_.Finish();
5893}
5894
5895flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5896
5897struct FullyConnectedOptionsT : public flatbuffers::NativeTable {
5898 typedef FullyConnectedOptions TableType;
5901 bool keep_num_dims = false;
5902 bool asymmetric_quantize_inputs = false;
5903};
5904
5905struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5908 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5913 };
5920 bool keep_num_dims() const {
5921 return GetField<uint8_t>(VT_KEEP_NUM_DIMS, 0) != 0;
5922 }
5924 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
5925 }
5926 bool Verify(flatbuffers::Verifier &verifier) const {
5927 return VerifyTableStart(verifier) &&
5928 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
5929 VerifyField<int8_t>(verifier, VT_WEIGHTS_FORMAT, 1) &&
5930 VerifyField<uint8_t>(verifier, VT_KEEP_NUM_DIMS, 1) &&
5931 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
5932 verifier.EndTable();
5933 }
5935 void UnPackTo(FullyConnectedOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
5936 static flatbuffers::Offset<FullyConnectedOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5937};
5938
5940 typedef FullyConnectedOptions Table;
5942 flatbuffers::uoffset_t start_;
5944 fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
5945 }
5947 fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_WEIGHTS_FORMAT, static_cast<int8_t>(weights_format), 0);
5948 }
5949 void add_keep_num_dims(bool keep_num_dims) {
5950 fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_KEEP_NUM_DIMS, static_cast<uint8_t>(keep_num_dims), 0);
5951 }
5952 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
5953 fbb_.AddElement<uint8_t>(FullyConnectedOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
5954 }
5956 : fbb_(_fbb) {
5957 start_ = fbb_.StartTable();
5958 }
5959 flatbuffers::Offset<FullyConnectedOptions> Finish() {
5960 const auto end = fbb_.EndTable(start_);
5961 auto o = flatbuffers::Offset<FullyConnectedOptions>(end);
5962 return o;
5963 }
5964};
5965
5966inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(
5970 bool keep_num_dims = false,
5971 bool asymmetric_quantize_inputs = false) {
5973 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
5974 builder_.add_keep_num_dims(keep_num_dims);
5975 builder_.add_weights_format(weights_format);
5976 builder_.add_fused_activation_function(fused_activation_function);
5977 return builder_.Finish();
5978}
5979
5980flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
5981
5982struct SoftmaxOptionsT : public flatbuffers::NativeTable {
5983 typedef SoftmaxOptions TableType;
5984 float beta = 0.0f;
5985};
5986
5987struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
5990 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
5991 VT_BETA = 4
5992 };
5993 float beta() const {
5994 return GetField<float>(VT_BETA, 0.0f);
5995 }
5996 bool Verify(flatbuffers::Verifier &verifier) const {
5997 return VerifyTableStart(verifier) &&
5998 VerifyField<float>(verifier, VT_BETA, 4) &&
5999 verifier.EndTable();
6000 }
6001 SoftmaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6002 void UnPackTo(SoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6003 static flatbuffers::Offset<SoftmaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6004};
6005
6006struct SoftmaxOptionsBuilder {
6007 typedef SoftmaxOptions Table;
6009 flatbuffers::uoffset_t start_;
6010 void add_beta(float beta) {
6011 fbb_.AddElement<float>(SoftmaxOptions::VT_BETA, beta, 0.0f);
6012 }
6014 : fbb_(_fbb) {
6015 start_ = fbb_.StartTable();
6016 }
6017 flatbuffers::Offset<SoftmaxOptions> Finish() {
6018 const auto end = fbb_.EndTable(start_);
6019 auto o = flatbuffers::Offset<SoftmaxOptions>(end);
6020 return o;
6021 }
6022};
6023
6024inline flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(
6026 float beta = 0.0f) {
6028 builder_.add_beta(beta);
6029 return builder_.Finish();
6030}
6031
6032flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6033
6034struct ConcatenationOptionsT : public flatbuffers::NativeTable {
6035 typedef ConcatenationOptions TableType;
6036 int32_t axis = 0;
6038};
6039
6040struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6043 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6046 };
6047 int32_t axis() const {
6048 return GetField<int32_t>(VT_AXIS, 0);
6049 }
6053 bool Verify(flatbuffers::Verifier &verifier) const {
6054 return VerifyTableStart(verifier) &&
6055 VerifyField<int32_t>(verifier, VT_AXIS, 4) &&
6056 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
6057 verifier.EndTable();
6058 }
6060 void UnPackTo(ConcatenationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6061 static flatbuffers::Offset<ConcatenationOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6062};
6063
6065 typedef ConcatenationOptions Table;
6067 flatbuffers::uoffset_t start_;
6068 void add_axis(int32_t axis) {
6069 fbb_.AddElement<int32_t>(ConcatenationOptions::VT_AXIS, axis, 0);
6070 }
6072 fbb_.AddElement<int8_t>(ConcatenationOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
6073 }
6075 : fbb_(_fbb) {
6076 start_ = fbb_.StartTable();
6077 }
6078 flatbuffers::Offset<ConcatenationOptions> Finish() {
6079 const auto end = fbb_.EndTable(start_);
6080 auto o = flatbuffers::Offset<ConcatenationOptions>(end);
6081 return o;
6082 }
6083};
6084
6085inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(
6087 int32_t axis = 0,
6090 builder_.add_axis(axis);
6091 builder_.add_fused_activation_function(fused_activation_function);
6092 return builder_.Finish();
6093}
6094
6095flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6096
6097struct AddOptionsT : public flatbuffers::NativeTable {
6098 typedef AddOptions TableType;
6100 bool pot_scale_int16 = true;
6101};
6102
6103struct AddOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6106 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6108 VT_POT_SCALE_INT16 = 6
6109 };
6113 bool pot_scale_int16() const {
6114 return GetField<uint8_t>(VT_POT_SCALE_INT16, 1) != 0;
6115 }
6116 bool Verify(flatbuffers::Verifier &verifier) const {
6117 return VerifyTableStart(verifier) &&
6118 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
6119 VerifyField<uint8_t>(verifier, VT_POT_SCALE_INT16, 1) &&
6120 verifier.EndTable();
6121 }
6122 AddOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6123 void UnPackTo(AddOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6124 static flatbuffers::Offset<AddOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6125};
6126
6127struct AddOptionsBuilder {
6128 typedef AddOptions Table;
6130 flatbuffers::uoffset_t start_;
6132 fbb_.AddElement<int8_t>(AddOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
6133 }
6134 void add_pot_scale_int16(bool pot_scale_int16) {
6135 fbb_.AddElement<uint8_t>(AddOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16), 1);
6136 }
6138 : fbb_(_fbb) {
6139 start_ = fbb_.StartTable();
6140 }
6141 flatbuffers::Offset<AddOptions> Finish() {
6142 const auto end = fbb_.EndTable(start_);
6143 auto o = flatbuffers::Offset<AddOptions>(end);
6144 return o;
6145 }
6146};
6147
6148inline flatbuffers::Offset<AddOptions> CreateAddOptions(
6151 bool pot_scale_int16 = true) {
6153 builder_.add_pot_scale_int16(pot_scale_int16);
6154 builder_.add_fused_activation_function(fused_activation_function);
6155 return builder_.Finish();
6156}
6157
6158flatbuffers::Offset<AddOptions> CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6159
6160struct MulOptionsT : public flatbuffers::NativeTable {
6161 typedef MulOptions TableType;
6163};
6164
6165struct MulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6168 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6170 };
6174 bool Verify(flatbuffers::Verifier &verifier) const {
6175 return VerifyTableStart(verifier) &&
6176 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
6177 verifier.EndTable();
6178 }
6179 MulOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6180 void UnPackTo(MulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6181 static flatbuffers::Offset<MulOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6182};
6183
6184struct MulOptionsBuilder {
6185 typedef MulOptions Table;
6187 flatbuffers::uoffset_t start_;
6189 fbb_.AddElement<int8_t>(MulOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
6190 }
6192 : fbb_(_fbb) {
6193 start_ = fbb_.StartTable();
6194 }
6195 flatbuffers::Offset<MulOptions> Finish() {
6196 const auto end = fbb_.EndTable(start_);
6197 auto o = flatbuffers::Offset<MulOptions>(end);
6198 return o;
6199 }
6200};
6201
6202inline flatbuffers::Offset<MulOptions> CreateMulOptions(
6206 builder_.add_fused_activation_function(fused_activation_function);
6207 return builder_.Finish();
6208}
6209
6210flatbuffers::Offset<MulOptions> CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6211
6212struct L2NormOptionsT : public flatbuffers::NativeTable {
6213 typedef L2NormOptions TableType;
6215};
6216
6217struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6220 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6222 };
6226 bool Verify(flatbuffers::Verifier &verifier) const {
6227 return VerifyTableStart(verifier) &&
6228 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
6229 verifier.EndTable();
6230 }
6231 L2NormOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6232 void UnPackTo(L2NormOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6233 static flatbuffers::Offset<L2NormOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6234};
6235
6236struct L2NormOptionsBuilder {
6237 typedef L2NormOptions Table;
6239 flatbuffers::uoffset_t start_;
6241 fbb_.AddElement<int8_t>(L2NormOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
6242 }
6244 : fbb_(_fbb) {
6245 start_ = fbb_.StartTable();
6246 }
6247 flatbuffers::Offset<L2NormOptions> Finish() {
6248 const auto end = fbb_.EndTable(start_);
6249 auto o = flatbuffers::Offset<L2NormOptions>(end);
6250 return o;
6251 }
6252};
6253
6254inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(
6258 builder_.add_fused_activation_function(fused_activation_function);
6259 return builder_.Finish();
6260}
6261
6262flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6263
6264struct LocalResponseNormalizationOptionsT : public flatbuffers::NativeTable {
6265 typedef LocalResponseNormalizationOptions TableType;
6266 int32_t radius = 0;
6267 float bias = 0.0f;
6268 float alpha = 0.0f;
6269 float beta = 0.0f;
6270};
6271
6272struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6275 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6279 VT_BETA = 10
6280 };
6281 int32_t radius() const {
6282 return GetField<int32_t>(VT_RADIUS, 0);
6283 }
6284 float bias() const {
6285 return GetField<float>(VT_BIAS, 0.0f);
6286 }
6287 float alpha() const {
6288 return GetField<float>(VT_ALPHA, 0.0f);
6289 }
6290 float beta() const {
6291 return GetField<float>(VT_BETA, 0.0f);
6292 }
6293 bool Verify(flatbuffers::Verifier &verifier) const {
6294 return VerifyTableStart(verifier) &&
6295 VerifyField<int32_t>(verifier, VT_RADIUS, 4) &&
6296 VerifyField<float>(verifier, VT_BIAS, 4) &&
6297 VerifyField<float>(verifier, VT_ALPHA, 4) &&
6298 VerifyField<float>(verifier, VT_BETA, 4) &&
6299 verifier.EndTable();
6300 }
6303 static flatbuffers::Offset<LocalResponseNormalizationOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6304};
6305
6307 typedef LocalResponseNormalizationOptions Table;
6309 flatbuffers::uoffset_t start_;
6310 void add_radius(int32_t radius) {
6311 fbb_.AddElement<int32_t>(LocalResponseNormalizationOptions::VT_RADIUS, radius, 0);
6312 }
6313 void add_bias(float bias) {
6314 fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BIAS, bias, 0.0f);
6315 }
6316 void add_alpha(float alpha) {
6317 fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_ALPHA, alpha, 0.0f);
6318 }
6319 void add_beta(float beta) {
6320 fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BETA, beta, 0.0f);
6321 }
6323 : fbb_(_fbb) {
6324 start_ = fbb_.StartTable();
6325 }
6326 flatbuffers::Offset<LocalResponseNormalizationOptions> Finish() {
6327 const auto end = fbb_.EndTable(start_);
6328 auto o = flatbuffers::Offset<LocalResponseNormalizationOptions>(end);
6329 return o;
6330 }
6331};
6332
6333inline flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(
6335 int32_t radius = 0,
6336 float bias = 0.0f,
6337 float alpha = 0.0f,
6338 float beta = 0.0f) {
6340 builder_.add_beta(beta);
6341 builder_.add_alpha(alpha);
6342 builder_.add_bias(bias);
6343 builder_.add_radius(radius);
6344 return builder_.Finish();
6345}
6346
6347flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6348
6349struct LSTMOptionsT : public flatbuffers::NativeTable {
6350 typedef LSTMOptions TableType;
6352 float cell_clip = 0.0f;
6353 float proj_clip = 0.0f;
6355 bool asymmetric_quantize_inputs = false;
6356};
6357
6358struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6361 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6367 };
6371 float cell_clip() const {
6372 return GetField<float>(VT_CELL_CLIP, 0.0f);
6373 }
6374 float proj_clip() const {
6375 return GetField<float>(VT_PROJ_CLIP, 0.0f);
6376 }
6378 return static_cast<tflite::LSTMKernelType>(GetField<int8_t>(VT_KERNEL_TYPE, 0));
6379 }
6381 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
6382 }
6383 bool Verify(flatbuffers::Verifier &verifier) const {
6384 return VerifyTableStart(verifier) &&
6385 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
6386 VerifyField<float>(verifier, VT_CELL_CLIP, 4) &&
6387 VerifyField<float>(verifier, VT_PROJ_CLIP, 4) &&
6388 VerifyField<int8_t>(verifier, VT_KERNEL_TYPE, 1) &&
6389 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
6390 verifier.EndTable();
6391 }
6392 LSTMOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6393 void UnPackTo(LSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6394 static flatbuffers::Offset<LSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6395};
6396
6397struct LSTMOptionsBuilder {
6398 typedef LSTMOptions Table;
6400 flatbuffers::uoffset_t start_;
6402 fbb_.AddElement<int8_t>(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
6403 }
6404 void add_cell_clip(float cell_clip) {
6405 fbb_.AddElement<float>(LSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
6406 }
6407 void add_proj_clip(float proj_clip) {
6408 fbb_.AddElement<float>(LSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
6409 }
6411 fbb_.AddElement<int8_t>(LSTMOptions::VT_KERNEL_TYPE, static_cast<int8_t>(kernel_type), 0);
6412 }
6413 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
6414 fbb_.AddElement<uint8_t>(LSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
6415 }
6417 : fbb_(_fbb) {
6418 start_ = fbb_.StartTable();
6419 }
6420 flatbuffers::Offset<LSTMOptions> Finish() {
6421 const auto end = fbb_.EndTable(start_);
6422 auto o = flatbuffers::Offset<LSTMOptions>(end);
6423 return o;
6424 }
6425};
6426
6427inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(
6430 float cell_clip = 0.0f,
6431 float proj_clip = 0.0f,
6433 bool asymmetric_quantize_inputs = false) {
6435 builder_.add_proj_clip(proj_clip);
6436 builder_.add_cell_clip(cell_clip);
6437 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
6438 builder_.add_kernel_type(kernel_type);
6439 builder_.add_fused_activation_function(fused_activation_function);
6440 return builder_.Finish();
6441}
6442
6443flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6444
6445struct UnidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable {
6446 typedef UnidirectionalSequenceLSTMOptions TableType;
6448 float cell_clip = 0.0f;
6449 float proj_clip = 0.0f;
6450 bool time_major = false;
6451 bool asymmetric_quantize_inputs = false;
6452 bool diagonal_recurrent_tensors = false;
6453};
6454
6455struct UnidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6458 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6460 VT_CELL_CLIP = 6,
6461 VT_PROJ_CLIP = 8,
6462 VT_TIME_MAJOR = 10,
6464 VT_DIAGONAL_RECURRENT_TENSORS = 14
6465 };
6469 float cell_clip() const {
6470 return GetField<float>(VT_CELL_CLIP, 0.0f);
6471 }
6472 float proj_clip() const {
6473 return GetField<float>(VT_PROJ_CLIP, 0.0f);
6474 }
6475 bool time_major() const {
6476 return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0;
6477 }
6479 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
6480 }
6482 return GetField<uint8_t>(VT_DIAGONAL_RECURRENT_TENSORS, 0) != 0;
6483 }
6484 bool Verify(flatbuffers::Verifier &verifier) const {
6485 return VerifyTableStart(verifier) &&
6486 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
6487 VerifyField<float>(verifier, VT_CELL_CLIP, 4) &&
6488 VerifyField<float>(verifier, VT_PROJ_CLIP, 4) &&
6489 VerifyField<uint8_t>(verifier, VT_TIME_MAJOR, 1) &&
6490 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
6491 VerifyField<uint8_t>(verifier, VT_DIAGONAL_RECURRENT_TENSORS, 1) &&
6492 verifier.EndTable();
6493 }
6496 static flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6497};
6498
6500 typedef UnidirectionalSequenceLSTMOptions Table;
6502 flatbuffers::uoffset_t start_;
6504 fbb_.AddElement<int8_t>(UnidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
6505 }
6506 void add_cell_clip(float cell_clip) {
6507 fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
6508 }
6509 void add_proj_clip(float proj_clip) {
6510 fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
6511 }
6512 void add_time_major(bool time_major) {
6513 fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0);
6514 }
6515 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
6516 fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
6517 }
6518 void add_diagonal_recurrent_tensors(bool diagonal_recurrent_tensors) {
6519 fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_DIAGONAL_RECURRENT_TENSORS, static_cast<uint8_t>(diagonal_recurrent_tensors), 0);
6520 }
6522 : fbb_(_fbb) {
6523 start_ = fbb_.StartTable();
6524 }
6525 flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Finish() {
6526 const auto end = fbb_.EndTable(start_);
6527 auto o = flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>(end);
6528 return o;
6529 }
6530};
6531
6532inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(
6535 float cell_clip = 0.0f,
6536 float proj_clip = 0.0f,
6537 bool time_major = false,
6538 bool asymmetric_quantize_inputs = false,
6539 bool diagonal_recurrent_tensors = false) {
6541 builder_.add_proj_clip(proj_clip);
6542 builder_.add_cell_clip(cell_clip);
6543 builder_.add_diagonal_recurrent_tensors(diagonal_recurrent_tensors);
6544 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
6545 builder_.add_time_major(time_major);
6546 builder_.add_fused_activation_function(fused_activation_function);
6547 return builder_.Finish();
6548}
6549
6550flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6551
6552struct BidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable {
6553 typedef BidirectionalSequenceLSTMOptions TableType;
6555 float cell_clip = 0.0f;
6556 float proj_clip = 0.0f;
6557 bool merge_outputs = false;
6558 bool time_major = true;
6559 bool asymmetric_quantize_inputs = false;
6560};
6561
6562struct BidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6565 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6567 VT_CELL_CLIP = 6,
6568 VT_PROJ_CLIP = 8,
6569 VT_MERGE_OUTPUTS = 10,
6570 VT_TIME_MAJOR = 12,
6572 };
6576 float cell_clip() const {
6577 return GetField<float>(VT_CELL_CLIP, 0.0f);
6578 }
6579 float proj_clip() const {
6580 return GetField<float>(VT_PROJ_CLIP, 0.0f);
6581 }
6582 bool merge_outputs() const {
6583 return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0;
6584 }
6585 bool time_major() const {
6586 return GetField<uint8_t>(VT_TIME_MAJOR, 1) != 0;
6587 }
6589 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
6590 }
6591 bool Verify(flatbuffers::Verifier &verifier) const {
6592 return VerifyTableStart(verifier) &&
6593 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
6594 VerifyField<float>(verifier, VT_CELL_CLIP, 4) &&
6595 VerifyField<float>(verifier, VT_PROJ_CLIP, 4) &&
6596 VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS, 1) &&
6597 VerifyField<uint8_t>(verifier, VT_TIME_MAJOR, 1) &&
6598 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
6599 verifier.EndTable();
6600 }
6603 static flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6604};
6605
6607 typedef BidirectionalSequenceLSTMOptions Table;
6609 flatbuffers::uoffset_t start_;
6611 fbb_.AddElement<int8_t>(BidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
6612 }
6613 void add_cell_clip(float cell_clip) {
6614 fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f);
6615 }
6616 void add_proj_clip(float proj_clip) {
6617 fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f);
6618 }
6619 void add_merge_outputs(bool merge_outputs) {
6620 fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_MERGE_OUTPUTS, static_cast<uint8_t>(merge_outputs), 0);
6621 }
6622 void add_time_major(bool time_major) {
6623 fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 1);
6624 }
6625 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
6626 fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
6627 }
6629 : fbb_(_fbb) {
6630 start_ = fbb_.StartTable();
6631 }
6632 flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Finish() {
6633 const auto end = fbb_.EndTable(start_);
6634 auto o = flatbuffers::Offset<BidirectionalSequenceLSTMOptions>(end);
6635 return o;
6636 }
6637};
6638
6639inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(
6642 float cell_clip = 0.0f,
6643 float proj_clip = 0.0f,
6644 bool merge_outputs = false,
6645 bool time_major = true,
6646 bool asymmetric_quantize_inputs = false) {
6648 builder_.add_proj_clip(proj_clip);
6649 builder_.add_cell_clip(cell_clip);
6650 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
6651 builder_.add_time_major(time_major);
6652 builder_.add_merge_outputs(merge_outputs);
6653 builder_.add_fused_activation_function(fused_activation_function);
6654 return builder_.Finish();
6655}
6656
6657flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6658
6659struct ResizeBilinearOptionsT : public flatbuffers::NativeTable {
6660 typedef ResizeBilinearOptions TableType;
6661 bool align_corners = false;
6662 bool half_pixel_centers = false;
6663};
6664
6665struct ResizeBilinearOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6668 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6670 VT_HALF_PIXEL_CENTERS = 10
6671 };
6672 bool align_corners() const {
6673 return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0;
6674 }
6675 bool half_pixel_centers() const {
6676 return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, 0) != 0;
6677 }
6678 bool Verify(flatbuffers::Verifier &verifier) const {
6679 return VerifyTableStart(verifier) &&
6680 VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS, 1) &&
6681 VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS, 1) &&
6682 verifier.EndTable();
6683 }
6685 void UnPackTo(ResizeBilinearOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6686 static flatbuffers::Offset<ResizeBilinearOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6687};
6688
6690 typedef ResizeBilinearOptions Table;
6692 flatbuffers::uoffset_t start_;
6693 void add_align_corners(bool align_corners) {
6694 fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), 0);
6695 }
6696 void add_half_pixel_centers(bool half_pixel_centers) {
6697 fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_HALF_PIXEL_CENTERS, static_cast<uint8_t>(half_pixel_centers), 0);
6698 }
6700 : fbb_(_fbb) {
6701 start_ = fbb_.StartTable();
6702 }
6703 flatbuffers::Offset<ResizeBilinearOptions> Finish() {
6704 const auto end = fbb_.EndTable(start_);
6705 auto o = flatbuffers::Offset<ResizeBilinearOptions>(end);
6706 return o;
6707 }
6708};
6709
6710inline flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(
6712 bool align_corners = false,
6713 bool half_pixel_centers = false) {
6715 builder_.add_half_pixel_centers(half_pixel_centers);
6716 builder_.add_align_corners(align_corners);
6717 return builder_.Finish();
6718}
6719
6720flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6721
6722struct ResizeNearestNeighborOptionsT : public flatbuffers::NativeTable {
6723 typedef ResizeNearestNeighborOptions TableType;
6724 bool align_corners = false;
6725 bool half_pixel_centers = false;
6726};
6727
6728struct ResizeNearestNeighborOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6731 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6732 VT_ALIGN_CORNERS = 4,
6733 VT_HALF_PIXEL_CENTERS = 6
6734 };
6735 bool align_corners() const {
6736 return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0;
6737 }
6738 bool half_pixel_centers() const {
6739 return GetField<uint8_t>(VT_HALF_PIXEL_CENTERS, 0) != 0;
6740 }
6741 bool Verify(flatbuffers::Verifier &verifier) const {
6742 return VerifyTableStart(verifier) &&
6743 VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS, 1) &&
6744 VerifyField<uint8_t>(verifier, VT_HALF_PIXEL_CENTERS, 1) &&
6745 verifier.EndTable();
6746 }
6749 static flatbuffers::Offset<ResizeNearestNeighborOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6750};
6751
6753 typedef ResizeNearestNeighborOptions Table;
6755 flatbuffers::uoffset_t start_;
6756 void add_align_corners(bool align_corners) {
6757 fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), 0);
6758 }
6759 void add_half_pixel_centers(bool half_pixel_centers) {
6760 fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_HALF_PIXEL_CENTERS, static_cast<uint8_t>(half_pixel_centers), 0);
6761 }
6763 : fbb_(_fbb) {
6764 start_ = fbb_.StartTable();
6765 }
6766 flatbuffers::Offset<ResizeNearestNeighborOptions> Finish() {
6767 const auto end = fbb_.EndTable(start_);
6768 auto o = flatbuffers::Offset<ResizeNearestNeighborOptions>(end);
6769 return o;
6770 }
6771};
6772
6773inline flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(
6775 bool align_corners = false,
6776 bool half_pixel_centers = false) {
6778 builder_.add_half_pixel_centers(half_pixel_centers);
6779 builder_.add_align_corners(align_corners);
6780 return builder_.Finish();
6781}
6782
6783flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6784
6785struct CallOptionsT : public flatbuffers::NativeTable {
6786 typedef CallOptions TableType;
6787 uint32_t subgraph = 0;
6788};
6789
6790struct CallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6793 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6794 VT_SUBGRAPH = 4
6795 };
6796 uint32_t subgraph() const {
6797 return GetField<uint32_t>(VT_SUBGRAPH, 0);
6798 }
6799 bool Verify(flatbuffers::Verifier &verifier) const {
6800 return VerifyTableStart(verifier) &&
6801 VerifyField<uint32_t>(verifier, VT_SUBGRAPH, 4) &&
6802 verifier.EndTable();
6803 }
6804 CallOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6805 void UnPackTo(CallOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6806 static flatbuffers::Offset<CallOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6807};
6808
6809struct CallOptionsBuilder {
6810 typedef CallOptions Table;
6812 flatbuffers::uoffset_t start_;
6813 void add_subgraph(uint32_t subgraph) {
6814 fbb_.AddElement<uint32_t>(CallOptions::VT_SUBGRAPH, subgraph, 0);
6815 }
6817 : fbb_(_fbb) {
6818 start_ = fbb_.StartTable();
6819 }
6820 flatbuffers::Offset<CallOptions> Finish() {
6821 const auto end = fbb_.EndTable(start_);
6822 auto o = flatbuffers::Offset<CallOptions>(end);
6823 return o;
6824 }
6825};
6826
6827inline flatbuffers::Offset<CallOptions> CreateCallOptions(
6829 uint32_t subgraph = 0) {
6831 builder_.add_subgraph(subgraph);
6832 return builder_.Finish();
6833}
6834
6835flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6836
6837struct PadOptionsT : public flatbuffers::NativeTable {
6838 typedef PadOptions TableType;
6839};
6840
6841struct PadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6844 bool Verify(flatbuffers::Verifier &verifier) const {
6845 return VerifyTableStart(verifier) &&
6846 verifier.EndTable();
6847 }
6848 PadOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6849 void UnPackTo(PadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6850 static flatbuffers::Offset<PadOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6851};
6852
6853struct PadOptionsBuilder {
6854 typedef PadOptions Table;
6856 flatbuffers::uoffset_t start_;
6858 : fbb_(_fbb) {
6859 start_ = fbb_.StartTable();
6860 }
6861 flatbuffers::Offset<PadOptions> Finish() {
6862 const auto end = fbb_.EndTable(start_);
6863 auto o = flatbuffers::Offset<PadOptions>(end);
6864 return o;
6865 }
6866};
6867
6868inline flatbuffers::Offset<PadOptions> CreatePadOptions(
6871 return builder_.Finish();
6872}
6873
6874flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6875
6876struct PadV2OptionsT : public flatbuffers::NativeTable {
6877 typedef PadV2Options TableType;
6878};
6879
6880struct PadV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6883 bool Verify(flatbuffers::Verifier &verifier) const {
6884 return VerifyTableStart(verifier) &&
6885 verifier.EndTable();
6886 }
6887 PadV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6888 void UnPackTo(PadV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6889 static flatbuffers::Offset<PadV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6890};
6891
6892struct PadV2OptionsBuilder {
6893 typedef PadV2Options Table;
6895 flatbuffers::uoffset_t start_;
6897 : fbb_(_fbb) {
6898 start_ = fbb_.StartTable();
6899 }
6900 flatbuffers::Offset<PadV2Options> Finish() {
6901 const auto end = fbb_.EndTable(start_);
6902 auto o = flatbuffers::Offset<PadV2Options>(end);
6903 return o;
6904 }
6905};
6906
6907inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(
6910 return builder_.Finish();
6911}
6912
6913flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6914
6915struct ReshapeOptionsT : public flatbuffers::NativeTable {
6916 typedef ReshapeOptions TableType;
6917 std::vector<int32_t> new_shape{};
6918};
6919
6920struct ReshapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6923 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
6924 VT_NEW_SHAPE = 4
6925 };
6927 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NEW_SHAPE);
6928 }
6929 bool Verify(flatbuffers::Verifier &verifier) const {
6930 return VerifyTableStart(verifier) &&
6931 VerifyOffset(verifier, VT_NEW_SHAPE) &&
6932 verifier.VerifyVector(new_shape()) &&
6933 verifier.EndTable();
6934 }
6935 ReshapeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6936 void UnPackTo(ReshapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6937 static flatbuffers::Offset<ReshapeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6938};
6939
6940struct ReshapeOptionsBuilder {
6941 typedef ReshapeOptions Table;
6943 flatbuffers::uoffset_t start_;
6944 void add_new_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape) {
6945 fbb_.AddOffset(ReshapeOptions::VT_NEW_SHAPE, new_shape);
6946 }
6948 : fbb_(_fbb) {
6949 start_ = fbb_.StartTable();
6950 }
6951 flatbuffers::Offset<ReshapeOptions> Finish() {
6952 const auto end = fbb_.EndTable(start_);
6953 auto o = flatbuffers::Offset<ReshapeOptions>(end);
6954 return o;
6955 }
6956};
6957
6958inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(
6960 flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape = 0) {
6962 builder_.add_new_shape(new_shape);
6963 return builder_.Finish();
6964}
6965
6966inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptionsDirect(
6968 const std::vector<int32_t> *new_shape = nullptr) {
6969 auto new_shape__ = new_shape ? _fbb.CreateVector<int32_t>(*new_shape) : 0;
6971 _fbb,
6972 new_shape__);
6973}
6974
6975flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6976
6977struct SpaceToBatchNDOptionsT : public flatbuffers::NativeTable {
6978 typedef SpaceToBatchNDOptions TableType;
6979};
6980
6981struct SpaceToBatchNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
6984 bool Verify(flatbuffers::Verifier &verifier) const {
6985 return VerifyTableStart(verifier) &&
6986 verifier.EndTable();
6987 }
6989 void UnPackTo(SpaceToBatchNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
6990 static flatbuffers::Offset<SpaceToBatchNDOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
6991};
6992
6994 typedef SpaceToBatchNDOptions Table;
6996 flatbuffers::uoffset_t start_;
6998 : fbb_(_fbb) {
6999 start_ = fbb_.StartTable();
7000 }
7001 flatbuffers::Offset<SpaceToBatchNDOptions> Finish() {
7002 const auto end = fbb_.EndTable(start_);
7003 auto o = flatbuffers::Offset<SpaceToBatchNDOptions>(end);
7004 return o;
7005 }
7006};
7007
7008inline flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(
7011 return builder_.Finish();
7012}
7013
7014flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7015
7016struct BatchToSpaceNDOptionsT : public flatbuffers::NativeTable {
7017 typedef BatchToSpaceNDOptions TableType;
7018};
7019
7020struct BatchToSpaceNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7023 bool Verify(flatbuffers::Verifier &verifier) const {
7024 return VerifyTableStart(verifier) &&
7025 verifier.EndTable();
7026 }
7028 void UnPackTo(BatchToSpaceNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7029 static flatbuffers::Offset<BatchToSpaceNDOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7030};
7031
7033 typedef BatchToSpaceNDOptions Table;
7035 flatbuffers::uoffset_t start_;
7037 : fbb_(_fbb) {
7038 start_ = fbb_.StartTable();
7039 }
7040 flatbuffers::Offset<BatchToSpaceNDOptions> Finish() {
7041 const auto end = fbb_.EndTable(start_);
7042 auto o = flatbuffers::Offset<BatchToSpaceNDOptions>(end);
7043 return o;
7044 }
7045};
7046
7047inline flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(
7050 return builder_.Finish();
7051}
7052
7053flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7054
7055struct SkipGramOptionsT : public flatbuffers::NativeTable {
7056 typedef SkipGramOptions TableType;
7057 int32_t ngram_size = 0;
7058 int32_t max_skip_size = 0;
7059 bool include_all_ngrams = false;
7060};
7061
7062struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7065 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7068 VT_INCLUDE_ALL_NGRAMS = 8
7069 };
7070 int32_t ngram_size() const {
7071 return GetField<int32_t>(VT_NGRAM_SIZE, 0);
7072 }
7073 int32_t max_skip_size() const {
7074 return GetField<int32_t>(VT_MAX_SKIP_SIZE, 0);
7075 }
7076 bool include_all_ngrams() const {
7077 return GetField<uint8_t>(VT_INCLUDE_ALL_NGRAMS, 0) != 0;
7078 }
7079 bool Verify(flatbuffers::Verifier &verifier) const {
7080 return VerifyTableStart(verifier) &&
7081 VerifyField<int32_t>(verifier, VT_NGRAM_SIZE, 4) &&
7082 VerifyField<int32_t>(verifier, VT_MAX_SKIP_SIZE, 4) &&
7083 VerifyField<uint8_t>(verifier, VT_INCLUDE_ALL_NGRAMS, 1) &&
7084 verifier.EndTable();
7085 }
7087 void UnPackTo(SkipGramOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7088 static flatbuffers::Offset<SkipGramOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7089};
7090
7092 typedef SkipGramOptions Table;
7094 flatbuffers::uoffset_t start_;
7095 void add_ngram_size(int32_t ngram_size) {
7096 fbb_.AddElement<int32_t>(SkipGramOptions::VT_NGRAM_SIZE, ngram_size, 0);
7097 }
7098 void add_max_skip_size(int32_t max_skip_size) {
7099 fbb_.AddElement<int32_t>(SkipGramOptions::VT_MAX_SKIP_SIZE, max_skip_size, 0);
7100 }
7101 void add_include_all_ngrams(bool include_all_ngrams) {
7102 fbb_.AddElement<uint8_t>(SkipGramOptions::VT_INCLUDE_ALL_NGRAMS, static_cast<uint8_t>(include_all_ngrams), 0);
7103 }
7105 : fbb_(_fbb) {
7106 start_ = fbb_.StartTable();
7107 }
7108 flatbuffers::Offset<SkipGramOptions> Finish() {
7109 const auto end = fbb_.EndTable(start_);
7110 auto o = flatbuffers::Offset<SkipGramOptions>(end);
7111 return o;
7112 }
7113};
7114
7115inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(
7117 int32_t ngram_size = 0,
7118 int32_t max_skip_size = 0,
7119 bool include_all_ngrams = false) {
7121 builder_.add_max_skip_size(max_skip_size);
7122 builder_.add_ngram_size(ngram_size);
7123 builder_.add_include_all_ngrams(include_all_ngrams);
7124 return builder_.Finish();
7125}
7126
7127flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7128
7129struct SpaceToDepthOptionsT : public flatbuffers::NativeTable {
7130 typedef SpaceToDepthOptions TableType;
7131 int32_t block_size = 0;
7132};
7133
7134struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7137 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7138 VT_BLOCK_SIZE = 4
7139 };
7140 int32_t block_size() const {
7141 return GetField<int32_t>(VT_BLOCK_SIZE, 0);
7142 }
7143 bool Verify(flatbuffers::Verifier &verifier) const {
7144 return VerifyTableStart(verifier) &&
7145 VerifyField<int32_t>(verifier, VT_BLOCK_SIZE, 4) &&
7146 verifier.EndTable();
7147 }
7149 void UnPackTo(SpaceToDepthOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7150 static flatbuffers::Offset<SpaceToDepthOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7151};
7152
7154 typedef SpaceToDepthOptions Table;
7156 flatbuffers::uoffset_t start_;
7158 fbb_.AddElement<int32_t>(SpaceToDepthOptions::VT_BLOCK_SIZE, block_size, 0);
7159 }
7161 : fbb_(_fbb) {
7162 start_ = fbb_.StartTable();
7163 }
7164 flatbuffers::Offset<SpaceToDepthOptions> Finish() {
7165 const auto end = fbb_.EndTable(start_);
7166 auto o = flatbuffers::Offset<SpaceToDepthOptions>(end);
7167 return o;
7168 }
7169};
7170
7171inline flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(
7173 int32_t block_size = 0) {
7175 builder_.add_block_size(block_size);
7176 return builder_.Finish();
7177}
7178
7179flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7180
7181struct DepthToSpaceOptionsT : public flatbuffers::NativeTable {
7182 typedef DepthToSpaceOptions TableType;
7183 int32_t block_size = 0;
7184};
7185
7186struct DepthToSpaceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7189 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7190 VT_BLOCK_SIZE = 4
7191 };
7192 int32_t block_size() const {
7193 return GetField<int32_t>(VT_BLOCK_SIZE, 0);
7194 }
7195 bool Verify(flatbuffers::Verifier &verifier) const {
7196 return VerifyTableStart(verifier) &&
7197 VerifyField<int32_t>(verifier, VT_BLOCK_SIZE, 4) &&
7198 verifier.EndTable();
7199 }
7201 void UnPackTo(DepthToSpaceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7202 static flatbuffers::Offset<DepthToSpaceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7203};
7204
7206 typedef DepthToSpaceOptions Table;
7208 flatbuffers::uoffset_t start_;
7210 fbb_.AddElement<int32_t>(DepthToSpaceOptions::VT_BLOCK_SIZE, block_size, 0);
7211 }
7213 : fbb_(_fbb) {
7214 start_ = fbb_.StartTable();
7215 }
7216 flatbuffers::Offset<DepthToSpaceOptions> Finish() {
7217 const auto end = fbb_.EndTable(start_);
7218 auto o = flatbuffers::Offset<DepthToSpaceOptions>(end);
7219 return o;
7220 }
7221};
7222
7223inline flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(
7225 int32_t block_size = 0) {
7227 builder_.add_block_size(block_size);
7228 return builder_.Finish();
7229}
7230
7231flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7232
7233struct SubOptionsT : public flatbuffers::NativeTable {
7234 typedef SubOptions TableType;
7236 bool pot_scale_int16 = true;
7237};
7238
7239struct SubOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7242 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7244 VT_POT_SCALE_INT16 = 6
7245 };
7249 bool pot_scale_int16() const {
7250 return GetField<uint8_t>(VT_POT_SCALE_INT16, 1) != 0;
7251 }
7252 bool Verify(flatbuffers::Verifier &verifier) const {
7253 return VerifyTableStart(verifier) &&
7254 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
7255 VerifyField<uint8_t>(verifier, VT_POT_SCALE_INT16, 1) &&
7256 verifier.EndTable();
7257 }
7258 SubOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7259 void UnPackTo(SubOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7260 static flatbuffers::Offset<SubOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7261};
7262
7263struct SubOptionsBuilder {
7264 typedef SubOptions Table;
7266 flatbuffers::uoffset_t start_;
7268 fbb_.AddElement<int8_t>(SubOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
7269 }
7270 void add_pot_scale_int16(bool pot_scale_int16) {
7271 fbb_.AddElement<uint8_t>(SubOptions::VT_POT_SCALE_INT16, static_cast<uint8_t>(pot_scale_int16), 1);
7272 }
7274 : fbb_(_fbb) {
7275 start_ = fbb_.StartTable();
7276 }
7277 flatbuffers::Offset<SubOptions> Finish() {
7278 const auto end = fbb_.EndTable(start_);
7279 auto o = flatbuffers::Offset<SubOptions>(end);
7280 return o;
7281 }
7282};
7283
7284inline flatbuffers::Offset<SubOptions> CreateSubOptions(
7287 bool pot_scale_int16 = true) {
7289 builder_.add_pot_scale_int16(pot_scale_int16);
7290 builder_.add_fused_activation_function(fused_activation_function);
7291 return builder_.Finish();
7292}
7293
7294flatbuffers::Offset<SubOptions> CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7295
7296struct DivOptionsT : public flatbuffers::NativeTable {
7297 typedef DivOptions TableType;
7299};
7300
7301struct DivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7304 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7306 };
7310 bool Verify(flatbuffers::Verifier &verifier) const {
7311 return VerifyTableStart(verifier) &&
7312 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
7313 verifier.EndTable();
7314 }
7315 DivOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7316 void UnPackTo(DivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7317 static flatbuffers::Offset<DivOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7318};
7319
7320struct DivOptionsBuilder {
7321 typedef DivOptions Table;
7323 flatbuffers::uoffset_t start_;
7325 fbb_.AddElement<int8_t>(DivOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
7326 }
7328 : fbb_(_fbb) {
7329 start_ = fbb_.StartTable();
7330 }
7331 flatbuffers::Offset<DivOptions> Finish() {
7332 const auto end = fbb_.EndTable(start_);
7333 auto o = flatbuffers::Offset<DivOptions>(end);
7334 return o;
7335 }
7336};
7337
7338inline flatbuffers::Offset<DivOptions> CreateDivOptions(
7342 builder_.add_fused_activation_function(fused_activation_function);
7343 return builder_.Finish();
7344}
7345
7346flatbuffers::Offset<DivOptions> CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7347
7348struct TopKV2OptionsT : public flatbuffers::NativeTable {
7349 typedef TopKV2Options TableType;
7350};
7351
7352struct TopKV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7355 bool Verify(flatbuffers::Verifier &verifier) const {
7356 return VerifyTableStart(verifier) &&
7357 verifier.EndTable();
7358 }
7359 TopKV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7360 void UnPackTo(TopKV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7361 static flatbuffers::Offset<TopKV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7362};
7363
7364struct TopKV2OptionsBuilder {
7365 typedef TopKV2Options Table;
7367 flatbuffers::uoffset_t start_;
7369 : fbb_(_fbb) {
7370 start_ = fbb_.StartTable();
7371 }
7372 flatbuffers::Offset<TopKV2Options> Finish() {
7373 const auto end = fbb_.EndTable(start_);
7374 auto o = flatbuffers::Offset<TopKV2Options>(end);
7375 return o;
7376 }
7377};
7378
7379inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(
7382 return builder_.Finish();
7383}
7384
7385flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7386
7387struct EmbeddingLookupSparseOptionsT : public flatbuffers::NativeTable {
7388 typedef EmbeddingLookupSparseOptions TableType;
7390};
7391
7392struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7395 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7396 VT_COMBINER = 4
7397 };
7399 return static_cast<tflite::CombinerType>(GetField<int8_t>(VT_COMBINER, 0));
7400 }
7401 bool Verify(flatbuffers::Verifier &verifier) const {
7402 return VerifyTableStart(verifier) &&
7403 VerifyField<int8_t>(verifier, VT_COMBINER, 1) &&
7404 verifier.EndTable();
7405 }
7408 static flatbuffers::Offset<EmbeddingLookupSparseOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7409};
7410
7412 typedef EmbeddingLookupSparseOptions Table;
7414 flatbuffers::uoffset_t start_;
7416 fbb_.AddElement<int8_t>(EmbeddingLookupSparseOptions::VT_COMBINER, static_cast<int8_t>(combiner), 0);
7417 }
7419 : fbb_(_fbb) {
7420 start_ = fbb_.StartTable();
7421 }
7422 flatbuffers::Offset<EmbeddingLookupSparseOptions> Finish() {
7423 const auto end = fbb_.EndTable(start_);
7424 auto o = flatbuffers::Offset<EmbeddingLookupSparseOptions>(end);
7425 return o;
7426 }
7427};
7428
7429inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(
7433 builder_.add_combiner(combiner);
7434 return builder_.Finish();
7435}
7436
7437flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7438
7439struct GatherOptionsT : public flatbuffers::NativeTable {
7440 typedef GatherOptions TableType;
7441 int32_t axis = 0;
7442 int32_t batch_dims = 0;
7443};
7444
7445struct GatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7448 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7449 VT_AXIS = 4,
7450 VT_BATCH_DIMS = 6
7451 };
7452 int32_t axis() const {
7453 return GetField<int32_t>(VT_AXIS, 0);
7454 }
7455 int32_t batch_dims() const {
7456 return GetField<int32_t>(VT_BATCH_DIMS, 0);
7457 }
7458 bool Verify(flatbuffers::Verifier &verifier) const {
7459 return VerifyTableStart(verifier) &&
7460 VerifyField<int32_t>(verifier, VT_AXIS, 4) &&
7461 VerifyField<int32_t>(verifier, VT_BATCH_DIMS, 4) &&
7462 verifier.EndTable();
7463 }
7464 GatherOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7465 void UnPackTo(GatherOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7466 static flatbuffers::Offset<GatherOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7467};
7468
7469struct GatherOptionsBuilder {
7470 typedef GatherOptions Table;
7472 flatbuffers::uoffset_t start_;
7473 void add_axis(int32_t axis) {
7474 fbb_.AddElement<int32_t>(GatherOptions::VT_AXIS, axis, 0);
7475 }
7476 void add_batch_dims(int32_t batch_dims) {
7477 fbb_.AddElement<int32_t>(GatherOptions::VT_BATCH_DIMS, batch_dims, 0);
7478 }
7480 : fbb_(_fbb) {
7481 start_ = fbb_.StartTable();
7482 }
7483 flatbuffers::Offset<GatherOptions> Finish() {
7484 const auto end = fbb_.EndTable(start_);
7485 auto o = flatbuffers::Offset<GatherOptions>(end);
7486 return o;
7487 }
7488};
7489
7490inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(
7492 int32_t axis = 0,
7493 int32_t batch_dims = 0) {
7495 builder_.add_batch_dims(batch_dims);
7496 builder_.add_axis(axis);
7497 return builder_.Finish();
7498}
7499
7500flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7501
7502struct TransposeOptionsT : public flatbuffers::NativeTable {
7503 typedef TransposeOptions TableType;
7504};
7505
7506struct TransposeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7509 bool Verify(flatbuffers::Verifier &verifier) const {
7510 return VerifyTableStart(verifier) &&
7511 verifier.EndTable();
7512 }
7514 void UnPackTo(TransposeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7515 static flatbuffers::Offset<TransposeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7516};
7517
7519 typedef TransposeOptions Table;
7521 flatbuffers::uoffset_t start_;
7523 : fbb_(_fbb) {
7524 start_ = fbb_.StartTable();
7525 }
7526 flatbuffers::Offset<TransposeOptions> Finish() {
7527 const auto end = fbb_.EndTable(start_);
7528 auto o = flatbuffers::Offset<TransposeOptions>(end);
7529 return o;
7530 }
7531};
7532
7533inline flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(
7536 return builder_.Finish();
7537}
7538
7539flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7540
7541struct ExpOptionsT : public flatbuffers::NativeTable {
7542 typedef ExpOptions TableType;
7543};
7544
7545struct ExpOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7548 bool Verify(flatbuffers::Verifier &verifier) const {
7549 return VerifyTableStart(verifier) &&
7550 verifier.EndTable();
7551 }
7552 ExpOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7553 void UnPackTo(ExpOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7554 static flatbuffers::Offset<ExpOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7555};
7556
7557struct ExpOptionsBuilder {
7558 typedef ExpOptions Table;
7560 flatbuffers::uoffset_t start_;
7562 : fbb_(_fbb) {
7563 start_ = fbb_.StartTable();
7564 }
7565 flatbuffers::Offset<ExpOptions> Finish() {
7566 const auto end = fbb_.EndTable(start_);
7567 auto o = flatbuffers::Offset<ExpOptions>(end);
7568 return o;
7569 }
7570};
7571
7572inline flatbuffers::Offset<ExpOptions> CreateExpOptions(
7575 return builder_.Finish();
7576}
7577
7578flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7579
7580struct CosOptionsT : public flatbuffers::NativeTable {
7581 typedef CosOptions TableType;
7582};
7583
7584struct CosOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7587 bool Verify(flatbuffers::Verifier &verifier) const {
7588 return VerifyTableStart(verifier) &&
7589 verifier.EndTable();
7590 }
7591 CosOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7592 void UnPackTo(CosOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7593 static flatbuffers::Offset<CosOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7594};
7595
7596struct CosOptionsBuilder {
7597 typedef CosOptions Table;
7599 flatbuffers::uoffset_t start_;
7601 : fbb_(_fbb) {
7602 start_ = fbb_.StartTable();
7603 }
7604 flatbuffers::Offset<CosOptions> Finish() {
7605 const auto end = fbb_.EndTable(start_);
7606 auto o = flatbuffers::Offset<CosOptions>(end);
7607 return o;
7608 }
7609};
7610
7611inline flatbuffers::Offset<CosOptions> CreateCosOptions(
7614 return builder_.Finish();
7615}
7616
7617flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7618
7619struct ReducerOptionsT : public flatbuffers::NativeTable {
7620 typedef ReducerOptions TableType;
7621 bool keep_dims = false;
7622};
7623
7624struct ReducerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7627 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7628 VT_KEEP_DIMS = 4
7629 };
7630 bool keep_dims() const {
7631 return GetField<uint8_t>(VT_KEEP_DIMS, 0) != 0;
7632 }
7633 bool Verify(flatbuffers::Verifier &verifier) const {
7634 return VerifyTableStart(verifier) &&
7635 VerifyField<uint8_t>(verifier, VT_KEEP_DIMS, 1) &&
7636 verifier.EndTable();
7637 }
7638 ReducerOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7639 void UnPackTo(ReducerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7640 static flatbuffers::Offset<ReducerOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7641};
7642
7643struct ReducerOptionsBuilder {
7644 typedef ReducerOptions Table;
7646 flatbuffers::uoffset_t start_;
7647 void add_keep_dims(bool keep_dims) {
7648 fbb_.AddElement<uint8_t>(ReducerOptions::VT_KEEP_DIMS, static_cast<uint8_t>(keep_dims), 0);
7649 }
7651 : fbb_(_fbb) {
7652 start_ = fbb_.StartTable();
7653 }
7654 flatbuffers::Offset<ReducerOptions> Finish() {
7655 const auto end = fbb_.EndTable(start_);
7656 auto o = flatbuffers::Offset<ReducerOptions>(end);
7657 return o;
7658 }
7659};
7660
7661inline flatbuffers::Offset<ReducerOptions> CreateReducerOptions(
7663 bool keep_dims = false) {
7665 builder_.add_keep_dims(keep_dims);
7666 return builder_.Finish();
7667}
7668
7669flatbuffers::Offset<ReducerOptions> CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7670
7671struct SqueezeOptionsT : public flatbuffers::NativeTable {
7672 typedef SqueezeOptions TableType;
7673 std::vector<int32_t> squeeze_dims{};
7674};
7675
7676struct SqueezeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7679 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7680 VT_SQUEEZE_DIMS = 4
7681 };
7683 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SQUEEZE_DIMS);
7684 }
7685 bool Verify(flatbuffers::Verifier &verifier) const {
7686 return VerifyTableStart(verifier) &&
7687 VerifyOffset(verifier, VT_SQUEEZE_DIMS) &&
7688 verifier.VerifyVector(squeeze_dims()) &&
7689 verifier.EndTable();
7690 }
7691 SqueezeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7692 void UnPackTo(SqueezeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7693 static flatbuffers::Offset<SqueezeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7694};
7695
7696struct SqueezeOptionsBuilder {
7697 typedef SqueezeOptions Table;
7699 flatbuffers::uoffset_t start_;
7700 void add_squeeze_dims(flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims) {
7701 fbb_.AddOffset(SqueezeOptions::VT_SQUEEZE_DIMS, squeeze_dims);
7702 }
7704 : fbb_(_fbb) {
7705 start_ = fbb_.StartTable();
7706 }
7707 flatbuffers::Offset<SqueezeOptions> Finish() {
7708 const auto end = fbb_.EndTable(start_);
7709 auto o = flatbuffers::Offset<SqueezeOptions>(end);
7710 return o;
7711 }
7712};
7713
7714inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(
7716 flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims = 0) {
7718 builder_.add_squeeze_dims(squeeze_dims);
7719 return builder_.Finish();
7720}
7721
7722inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptionsDirect(
7724 const std::vector<int32_t> *squeeze_dims = nullptr) {
7725 auto squeeze_dims__ = squeeze_dims ? _fbb.CreateVector<int32_t>(*squeeze_dims) : 0;
7727 _fbb,
7728 squeeze_dims__);
7729}
7730
7731flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7732
7733struct SplitOptionsT : public flatbuffers::NativeTable {
7734 typedef SplitOptions TableType;
7735 int32_t num_splits = 0;
7736};
7737
7738struct SplitOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7741 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7742 VT_NUM_SPLITS = 4
7743 };
7744 int32_t num_splits() const {
7745 return GetField<int32_t>(VT_NUM_SPLITS, 0);
7746 }
7747 bool Verify(flatbuffers::Verifier &verifier) const {
7748 return VerifyTableStart(verifier) &&
7749 VerifyField<int32_t>(verifier, VT_NUM_SPLITS, 4) &&
7750 verifier.EndTable();
7751 }
7752 SplitOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7753 void UnPackTo(SplitOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7754 static flatbuffers::Offset<SplitOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7755};
7756
7757struct SplitOptionsBuilder {
7758 typedef SplitOptions Table;
7760 flatbuffers::uoffset_t start_;
7761 void add_num_splits(int32_t num_splits) {
7762 fbb_.AddElement<int32_t>(SplitOptions::VT_NUM_SPLITS, num_splits, 0);
7763 }
7765 : fbb_(_fbb) {
7766 start_ = fbb_.StartTable();
7767 }
7768 flatbuffers::Offset<SplitOptions> Finish() {
7769 const auto end = fbb_.EndTable(start_);
7770 auto o = flatbuffers::Offset<SplitOptions>(end);
7771 return o;
7772 }
7773};
7774
7775inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(
7777 int32_t num_splits = 0) {
7779 builder_.add_num_splits(num_splits);
7780 return builder_.Finish();
7781}
7782
7783flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7784
7785struct SplitVOptionsT : public flatbuffers::NativeTable {
7786 typedef SplitVOptions TableType;
7787 int32_t num_splits = 0;
7788};
7789
7790struct SplitVOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7793 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7794 VT_NUM_SPLITS = 4
7795 };
7796 int32_t num_splits() const {
7797 return GetField<int32_t>(VT_NUM_SPLITS, 0);
7798 }
7799 bool Verify(flatbuffers::Verifier &verifier) const {
7800 return VerifyTableStart(verifier) &&
7801 VerifyField<int32_t>(verifier, VT_NUM_SPLITS, 4) &&
7802 verifier.EndTable();
7803 }
7804 SplitVOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7805 void UnPackTo(SplitVOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7806 static flatbuffers::Offset<SplitVOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7807};
7808
7809struct SplitVOptionsBuilder {
7810 typedef SplitVOptions Table;
7812 flatbuffers::uoffset_t start_;
7813 void add_num_splits(int32_t num_splits) {
7814 fbb_.AddElement<int32_t>(SplitVOptions::VT_NUM_SPLITS, num_splits, 0);
7815 }
7817 : fbb_(_fbb) {
7818 start_ = fbb_.StartTable();
7819 }
7820 flatbuffers::Offset<SplitVOptions> Finish() {
7821 const auto end = fbb_.EndTable(start_);
7822 auto o = flatbuffers::Offset<SplitVOptions>(end);
7823 return o;
7824 }
7825};
7826
7827inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(
7829 int32_t num_splits = 0) {
7831 builder_.add_num_splits(num_splits);
7832 return builder_.Finish();
7833}
7834
7835flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7836
7837struct StridedSliceOptionsT : public flatbuffers::NativeTable {
7838 typedef StridedSliceOptions TableType;
7839 int32_t begin_mask = 0;
7840 int32_t end_mask = 0;
7841 int32_t ellipsis_mask = 0;
7842 int32_t new_axis_mask = 0;
7843 int32_t shrink_axis_mask = 0;
7844};
7845
7846struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7849 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7855 };
7856 int32_t begin_mask() const {
7857 return GetField<int32_t>(VT_BEGIN_MASK, 0);
7858 }
7859 int32_t end_mask() const {
7860 return GetField<int32_t>(VT_END_MASK, 0);
7861 }
7862 int32_t ellipsis_mask() const {
7863 return GetField<int32_t>(VT_ELLIPSIS_MASK, 0);
7864 }
7865 int32_t new_axis_mask() const {
7866 return GetField<int32_t>(VT_NEW_AXIS_MASK, 0);
7867 }
7868 int32_t shrink_axis_mask() const {
7869 return GetField<int32_t>(VT_SHRINK_AXIS_MASK, 0);
7870 }
7871 bool Verify(flatbuffers::Verifier &verifier) const {
7872 return VerifyTableStart(verifier) &&
7873 VerifyField<int32_t>(verifier, VT_BEGIN_MASK, 4) &&
7874 VerifyField<int32_t>(verifier, VT_END_MASK, 4) &&
7875 VerifyField<int32_t>(verifier, VT_ELLIPSIS_MASK, 4) &&
7876 VerifyField<int32_t>(verifier, VT_NEW_AXIS_MASK, 4) &&
7877 VerifyField<int32_t>(verifier, VT_SHRINK_AXIS_MASK, 4) &&
7878 verifier.EndTable();
7879 }
7881 void UnPackTo(StridedSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7882 static flatbuffers::Offset<StridedSliceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7883};
7884
7886 typedef StridedSliceOptions Table;
7888 flatbuffers::uoffset_t start_;
7889 void add_begin_mask(int32_t begin_mask) {
7890 fbb_.AddElement<int32_t>(StridedSliceOptions::VT_BEGIN_MASK, begin_mask, 0);
7891 }
7892 void add_end_mask(int32_t end_mask) {
7893 fbb_.AddElement<int32_t>(StridedSliceOptions::VT_END_MASK, end_mask, 0);
7894 }
7895 void add_ellipsis_mask(int32_t ellipsis_mask) {
7896 fbb_.AddElement<int32_t>(StridedSliceOptions::VT_ELLIPSIS_MASK, ellipsis_mask, 0);
7897 }
7898 void add_new_axis_mask(int32_t new_axis_mask) {
7899 fbb_.AddElement<int32_t>(StridedSliceOptions::VT_NEW_AXIS_MASK, new_axis_mask, 0);
7900 }
7901 void add_shrink_axis_mask(int32_t shrink_axis_mask) {
7902 fbb_.AddElement<int32_t>(StridedSliceOptions::VT_SHRINK_AXIS_MASK, shrink_axis_mask, 0);
7903 }
7905 : fbb_(_fbb) {
7906 start_ = fbb_.StartTable();
7907 }
7908 flatbuffers::Offset<StridedSliceOptions> Finish() {
7909 const auto end = fbb_.EndTable(start_);
7910 auto o = flatbuffers::Offset<StridedSliceOptions>(end);
7911 return o;
7912 }
7913};
7914
7915inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(
7917 int32_t begin_mask = 0,
7918 int32_t end_mask = 0,
7919 int32_t ellipsis_mask = 0,
7920 int32_t new_axis_mask = 0,
7921 int32_t shrink_axis_mask = 0) {
7923 builder_.add_shrink_axis_mask(shrink_axis_mask);
7924 builder_.add_new_axis_mask(new_axis_mask);
7925 builder_.add_ellipsis_mask(ellipsis_mask);
7926 builder_.add_end_mask(end_mask);
7927 builder_.add_begin_mask(begin_mask);
7928 return builder_.Finish();
7929}
7930
7931flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7932
7933struct LogSoftmaxOptionsT : public flatbuffers::NativeTable {
7934 typedef LogSoftmaxOptions TableType;
7935};
7936
7937struct LogSoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7940 bool Verify(flatbuffers::Verifier &verifier) const {
7941 return VerifyTableStart(verifier) &&
7942 verifier.EndTable();
7943 }
7945 void UnPackTo(LogSoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7946 static flatbuffers::Offset<LogSoftmaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7947};
7948
7950 typedef LogSoftmaxOptions Table;
7952 flatbuffers::uoffset_t start_;
7954 : fbb_(_fbb) {
7955 start_ = fbb_.StartTable();
7956 }
7957 flatbuffers::Offset<LogSoftmaxOptions> Finish() {
7958 const auto end = fbb_.EndTable(start_);
7959 auto o = flatbuffers::Offset<LogSoftmaxOptions>(end);
7960 return o;
7961 }
7962};
7963
7964inline flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(
7967 return builder_.Finish();
7968}
7969
7970flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
7971
7972struct CastOptionsT : public flatbuffers::NativeTable {
7973 typedef CastOptions TableType;
7976};
7977
7978struct CastOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
7981 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
7983 VT_OUT_DATA_TYPE = 6
7984 };
7986 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_IN_DATA_TYPE, 0));
7987 }
7989 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUT_DATA_TYPE, 0));
7990 }
7991 bool Verify(flatbuffers::Verifier &verifier) const {
7992 return VerifyTableStart(verifier) &&
7993 VerifyField<int8_t>(verifier, VT_IN_DATA_TYPE, 1) &&
7994 VerifyField<int8_t>(verifier, VT_OUT_DATA_TYPE, 1) &&
7995 verifier.EndTable();
7996 }
7997 CastOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7998 void UnPackTo(CastOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
7999 static flatbuffers::Offset<CastOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8000};
8001
8002struct CastOptionsBuilder {
8003 typedef CastOptions Table;
8005 flatbuffers::uoffset_t start_;
8007 fbb_.AddElement<int8_t>(CastOptions::VT_IN_DATA_TYPE, static_cast<int8_t>(in_data_type), 0);
8008 }
8010 fbb_.AddElement<int8_t>(CastOptions::VT_OUT_DATA_TYPE, static_cast<int8_t>(out_data_type), 0);
8011 }
8013 : fbb_(_fbb) {
8014 start_ = fbb_.StartTable();
8015 }
8016 flatbuffers::Offset<CastOptions> Finish() {
8017 const auto end = fbb_.EndTable(start_);
8018 auto o = flatbuffers::Offset<CastOptions>(end);
8019 return o;
8020 }
8021};
8022
8023inline flatbuffers::Offset<CastOptions> CreateCastOptions(
8028 builder_.add_out_data_type(out_data_type);
8029 builder_.add_in_data_type(in_data_type);
8030 return builder_.Finish();
8031}
8032
8033flatbuffers::Offset<CastOptions> CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8034
8035struct DequantizeOptionsT : public flatbuffers::NativeTable {
8036 typedef DequantizeOptions TableType;
8037};
8038
8039struct DequantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8042 bool Verify(flatbuffers::Verifier &verifier) const {
8043 return VerifyTableStart(verifier) &&
8044 verifier.EndTable();
8045 }
8047 void UnPackTo(DequantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8048 static flatbuffers::Offset<DequantizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8049};
8050
8052 typedef DequantizeOptions Table;
8054 flatbuffers::uoffset_t start_;
8056 : fbb_(_fbb) {
8057 start_ = fbb_.StartTable();
8058 }
8059 flatbuffers::Offset<DequantizeOptions> Finish() {
8060 const auto end = fbb_.EndTable(start_);
8061 auto o = flatbuffers::Offset<DequantizeOptions>(end);
8062 return o;
8063 }
8064};
8065
8066inline flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(
8069 return builder_.Finish();
8070}
8071
8072flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8073
8074struct MaximumMinimumOptionsT : public flatbuffers::NativeTable {
8075 typedef MaximumMinimumOptions TableType;
8076};
8077
8078struct MaximumMinimumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8081 bool Verify(flatbuffers::Verifier &verifier) const {
8082 return VerifyTableStart(verifier) &&
8083 verifier.EndTable();
8084 }
8086 void UnPackTo(MaximumMinimumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8087 static flatbuffers::Offset<MaximumMinimumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8088};
8089
8091 typedef MaximumMinimumOptions Table;
8093 flatbuffers::uoffset_t start_;
8095 : fbb_(_fbb) {
8096 start_ = fbb_.StartTable();
8097 }
8098 flatbuffers::Offset<MaximumMinimumOptions> Finish() {
8099 const auto end = fbb_.EndTable(start_);
8100 auto o = flatbuffers::Offset<MaximumMinimumOptions>(end);
8101 return o;
8102 }
8103};
8104
8105inline flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(
8108 return builder_.Finish();
8109}
8110
8111flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8112
8113struct TileOptionsT : public flatbuffers::NativeTable {
8114 typedef TileOptions TableType;
8115};
8116
8117struct TileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8120 bool Verify(flatbuffers::Verifier &verifier) const {
8121 return VerifyTableStart(verifier) &&
8122 verifier.EndTable();
8123 }
8124 TileOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8125 void UnPackTo(TileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8126 static flatbuffers::Offset<TileOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8127};
8128
8129struct TileOptionsBuilder {
8130 typedef TileOptions Table;
8132 flatbuffers::uoffset_t start_;
8134 : fbb_(_fbb) {
8135 start_ = fbb_.StartTable();
8136 }
8137 flatbuffers::Offset<TileOptions> Finish() {
8138 const auto end = fbb_.EndTable(start_);
8139 auto o = flatbuffers::Offset<TileOptions>(end);
8140 return o;
8141 }
8142};
8143
8144inline flatbuffers::Offset<TileOptions> CreateTileOptions(
8147 return builder_.Finish();
8148}
8149
8150flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8151
8152struct ArgMaxOptionsT : public flatbuffers::NativeTable {
8153 typedef ArgMaxOptions TableType;
8155};
8156
8157struct ArgMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8160 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8161 VT_OUTPUT_TYPE = 4
8162 };
8164 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
8165 }
8166 bool Verify(flatbuffers::Verifier &verifier) const {
8167 return VerifyTableStart(verifier) &&
8168 VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE, 1) &&
8169 verifier.EndTable();
8170 }
8171 ArgMaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8172 void UnPackTo(ArgMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8173 static flatbuffers::Offset<ArgMaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8174};
8175
8176struct ArgMaxOptionsBuilder {
8177 typedef ArgMaxOptions Table;
8179 flatbuffers::uoffset_t start_;
8181 fbb_.AddElement<int8_t>(ArgMaxOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
8182 }
8184 : fbb_(_fbb) {
8185 start_ = fbb_.StartTable();
8186 }
8187 flatbuffers::Offset<ArgMaxOptions> Finish() {
8188 const auto end = fbb_.EndTable(start_);
8189 auto o = flatbuffers::Offset<ArgMaxOptions>(end);
8190 return o;
8191 }
8192};
8193
8194inline flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(
8198 builder_.add_output_type(output_type);
8199 return builder_.Finish();
8200}
8201
8202flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8203
8204struct ArgMinOptionsT : public flatbuffers::NativeTable {
8205 typedef ArgMinOptions TableType;
8207};
8208
8209struct ArgMinOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8212 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8213 VT_OUTPUT_TYPE = 4
8214 };
8216 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0));
8217 }
8218 bool Verify(flatbuffers::Verifier &verifier) const {
8219 return VerifyTableStart(verifier) &&
8220 VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE, 1) &&
8221 verifier.EndTable();
8222 }
8223 ArgMinOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8224 void UnPackTo(ArgMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8225 static flatbuffers::Offset<ArgMinOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8226};
8227
8228struct ArgMinOptionsBuilder {
8229 typedef ArgMinOptions Table;
8231 flatbuffers::uoffset_t start_;
8233 fbb_.AddElement<int8_t>(ArgMinOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0);
8234 }
8236 : fbb_(_fbb) {
8237 start_ = fbb_.StartTable();
8238 }
8239 flatbuffers::Offset<ArgMinOptions> Finish() {
8240 const auto end = fbb_.EndTable(start_);
8241 auto o = flatbuffers::Offset<ArgMinOptions>(end);
8242 return o;
8243 }
8244};
8245
8246inline flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(
8250 builder_.add_output_type(output_type);
8251 return builder_.Finish();
8252}
8253
8254flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8255
8256struct GreaterOptionsT : public flatbuffers::NativeTable {
8257 typedef GreaterOptions TableType;
8258};
8259
8260struct GreaterOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8263 bool Verify(flatbuffers::Verifier &verifier) const {
8264 return VerifyTableStart(verifier) &&
8265 verifier.EndTable();
8266 }
8267 GreaterOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8268 void UnPackTo(GreaterOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8269 static flatbuffers::Offset<GreaterOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8270};
8271
8272struct GreaterOptionsBuilder {
8273 typedef GreaterOptions Table;
8275 flatbuffers::uoffset_t start_;
8277 : fbb_(_fbb) {
8278 start_ = fbb_.StartTable();
8279 }
8280 flatbuffers::Offset<GreaterOptions> Finish() {
8281 const auto end = fbb_.EndTable(start_);
8282 auto o = flatbuffers::Offset<GreaterOptions>(end);
8283 return o;
8284 }
8285};
8286
8287inline flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(
8290 return builder_.Finish();
8291}
8292
8293flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8294
8295struct GreaterEqualOptionsT : public flatbuffers::NativeTable {
8296 typedef GreaterEqualOptions TableType;
8297};
8298
8299struct GreaterEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8302 bool Verify(flatbuffers::Verifier &verifier) const {
8303 return VerifyTableStart(verifier) &&
8304 verifier.EndTable();
8305 }
8307 void UnPackTo(GreaterEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8308 static flatbuffers::Offset<GreaterEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8309};
8310
8312 typedef GreaterEqualOptions Table;
8314 flatbuffers::uoffset_t start_;
8316 : fbb_(_fbb) {
8317 start_ = fbb_.StartTable();
8318 }
8319 flatbuffers::Offset<GreaterEqualOptions> Finish() {
8320 const auto end = fbb_.EndTable(start_);
8321 auto o = flatbuffers::Offset<GreaterEqualOptions>(end);
8322 return o;
8323 }
8324};
8325
8326inline flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(
8329 return builder_.Finish();
8330}
8331
8332flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8333
8334struct LessOptionsT : public flatbuffers::NativeTable {
8335 typedef LessOptions TableType;
8336};
8337
8338struct LessOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8341 bool Verify(flatbuffers::Verifier &verifier) const {
8342 return VerifyTableStart(verifier) &&
8343 verifier.EndTable();
8344 }
8345 LessOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8346 void UnPackTo(LessOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8347 static flatbuffers::Offset<LessOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8348};
8349
8350struct LessOptionsBuilder {
8351 typedef LessOptions Table;
8353 flatbuffers::uoffset_t start_;
8355 : fbb_(_fbb) {
8356 start_ = fbb_.StartTable();
8357 }
8358 flatbuffers::Offset<LessOptions> Finish() {
8359 const auto end = fbb_.EndTable(start_);
8360 auto o = flatbuffers::Offset<LessOptions>(end);
8361 return o;
8362 }
8363};
8364
8365inline flatbuffers::Offset<LessOptions> CreateLessOptions(
8368 return builder_.Finish();
8369}
8370
8371flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8372
8373struct LessEqualOptionsT : public flatbuffers::NativeTable {
8374 typedef LessEqualOptions TableType;
8375};
8376
8377struct LessEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8380 bool Verify(flatbuffers::Verifier &verifier) const {
8381 return VerifyTableStart(verifier) &&
8382 verifier.EndTable();
8383 }
8385 void UnPackTo(LessEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8386 static flatbuffers::Offset<LessEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8387};
8388
8390 typedef LessEqualOptions Table;
8392 flatbuffers::uoffset_t start_;
8394 : fbb_(_fbb) {
8395 start_ = fbb_.StartTable();
8396 }
8397 flatbuffers::Offset<LessEqualOptions> Finish() {
8398 const auto end = fbb_.EndTable(start_);
8399 auto o = flatbuffers::Offset<LessEqualOptions>(end);
8400 return o;
8401 }
8402};
8403
8404inline flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(
8407 return builder_.Finish();
8408}
8409
8410flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8411
8412struct NegOptionsT : public flatbuffers::NativeTable {
8413 typedef NegOptions TableType;
8414};
8415
8416struct NegOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8419 bool Verify(flatbuffers::Verifier &verifier) const {
8420 return VerifyTableStart(verifier) &&
8421 verifier.EndTable();
8422 }
8423 NegOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8424 void UnPackTo(NegOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8425 static flatbuffers::Offset<NegOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8426};
8427
8428struct NegOptionsBuilder {
8429 typedef NegOptions Table;
8431 flatbuffers::uoffset_t start_;
8433 : fbb_(_fbb) {
8434 start_ = fbb_.StartTable();
8435 }
8436 flatbuffers::Offset<NegOptions> Finish() {
8437 const auto end = fbb_.EndTable(start_);
8438 auto o = flatbuffers::Offset<NegOptions>(end);
8439 return o;
8440 }
8441};
8442
8443inline flatbuffers::Offset<NegOptions> CreateNegOptions(
8446 return builder_.Finish();
8447}
8448
8449flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8450
8451struct SelectOptionsT : public flatbuffers::NativeTable {
8452 typedef SelectOptions TableType;
8453};
8454
8455struct SelectOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8458 bool Verify(flatbuffers::Verifier &verifier) const {
8459 return VerifyTableStart(verifier) &&
8460 verifier.EndTable();
8461 }
8462 SelectOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8463 void UnPackTo(SelectOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8464 static flatbuffers::Offset<SelectOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8465};
8466
8467struct SelectOptionsBuilder {
8468 typedef SelectOptions Table;
8470 flatbuffers::uoffset_t start_;
8472 : fbb_(_fbb) {
8473 start_ = fbb_.StartTable();
8474 }
8475 flatbuffers::Offset<SelectOptions> Finish() {
8476 const auto end = fbb_.EndTable(start_);
8477 auto o = flatbuffers::Offset<SelectOptions>(end);
8478 return o;
8479 }
8480};
8481
8482inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(
8485 return builder_.Finish();
8486}
8487
8488flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8489
8490struct SliceOptionsT : public flatbuffers::NativeTable {
8491 typedef SliceOptions TableType;
8492};
8493
8494struct SliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8497 bool Verify(flatbuffers::Verifier &verifier) const {
8498 return VerifyTableStart(verifier) &&
8499 verifier.EndTable();
8500 }
8501 SliceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8502 void UnPackTo(SliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8503 static flatbuffers::Offset<SliceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8504};
8505
8506struct SliceOptionsBuilder {
8507 typedef SliceOptions Table;
8509 flatbuffers::uoffset_t start_;
8511 : fbb_(_fbb) {
8512 start_ = fbb_.StartTable();
8513 }
8514 flatbuffers::Offset<SliceOptions> Finish() {
8515 const auto end = fbb_.EndTable(start_);
8516 auto o = flatbuffers::Offset<SliceOptions>(end);
8517 return o;
8518 }
8519};
8520
8521inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(
8524 return builder_.Finish();
8525}
8526
8527flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8528
8529struct TransposeConvOptionsT : public flatbuffers::NativeTable {
8530 typedef TransposeConvOptions TableType;
8532 int32_t stride_w = 0;
8533 int32_t stride_h = 0;
8535};
8536
8537struct TransposeConvOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8540 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8541 VT_PADDING = 4,
8542 VT_STRIDE_W = 6,
8543 VT_STRIDE_H = 8,
8545 };
8547 return static_cast<tflite::Padding>(GetField<int8_t>(VT_PADDING, 0));
8548 }
8549 int32_t stride_w() const {
8550 return GetField<int32_t>(VT_STRIDE_W, 0);
8551 }
8552 int32_t stride_h() const {
8553 return GetField<int32_t>(VT_STRIDE_H, 0);
8554 }
8558 bool Verify(flatbuffers::Verifier &verifier) const {
8559 return VerifyTableStart(verifier) &&
8560 VerifyField<int8_t>(verifier, VT_PADDING, 1) &&
8561 VerifyField<int32_t>(verifier, VT_STRIDE_W, 4) &&
8562 VerifyField<int32_t>(verifier, VT_STRIDE_H, 4) &&
8563 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION, 1) &&
8564 verifier.EndTable();
8565 }
8567 void UnPackTo(TransposeConvOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8568 static flatbuffers::Offset<TransposeConvOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8569};
8570
8572 typedef TransposeConvOptions Table;
8574 flatbuffers::uoffset_t start_;
8576 fbb_.AddElement<int8_t>(TransposeConvOptions::VT_PADDING, static_cast<int8_t>(padding), 0);
8577 }
8578 void add_stride_w(int32_t stride_w) {
8579 fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_W, stride_w, 0);
8580 }
8581 void add_stride_h(int32_t stride_h) {
8582 fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_H, stride_h, 0);
8583 }
8585 fbb_.AddElement<int8_t>(TransposeConvOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0);
8586 }
8588 : fbb_(_fbb) {
8589 start_ = fbb_.StartTable();
8590 }
8591 flatbuffers::Offset<TransposeConvOptions> Finish() {
8592 const auto end = fbb_.EndTable(start_);
8593 auto o = flatbuffers::Offset<TransposeConvOptions>(end);
8594 return o;
8595 }
8596};
8597
8598inline flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(
8601 int32_t stride_w = 0,
8602 int32_t stride_h = 0,
8605 builder_.add_stride_h(stride_h);
8606 builder_.add_stride_w(stride_w);
8607 builder_.add_fused_activation_function(fused_activation_function);
8608 builder_.add_padding(padding);
8609 return builder_.Finish();
8610}
8611
8612flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8613
8614struct ExpandDimsOptionsT : public flatbuffers::NativeTable {
8615 typedef ExpandDimsOptions TableType;
8616};
8617
8618struct ExpandDimsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8621 bool Verify(flatbuffers::Verifier &verifier) const {
8622 return VerifyTableStart(verifier) &&
8623 verifier.EndTable();
8624 }
8626 void UnPackTo(ExpandDimsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8627 static flatbuffers::Offset<ExpandDimsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8628};
8629
8631 typedef ExpandDimsOptions Table;
8633 flatbuffers::uoffset_t start_;
8635 : fbb_(_fbb) {
8636 start_ = fbb_.StartTable();
8637 }
8638 flatbuffers::Offset<ExpandDimsOptions> Finish() {
8639 const auto end = fbb_.EndTable(start_);
8640 auto o = flatbuffers::Offset<ExpandDimsOptions>(end);
8641 return o;
8642 }
8643};
8644
8645inline flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(
8648 return builder_.Finish();
8649}
8650
8651flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8652
8653struct SparseToDenseOptionsT : public flatbuffers::NativeTable {
8654 typedef SparseToDenseOptions TableType;
8655 bool validate_indices = false;
8656};
8657
8658struct SparseToDenseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8661 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8662 VT_VALIDATE_INDICES = 4
8663 };
8664 bool validate_indices() const {
8665 return GetField<uint8_t>(VT_VALIDATE_INDICES, 0) != 0;
8666 }
8667 bool Verify(flatbuffers::Verifier &verifier) const {
8668 return VerifyTableStart(verifier) &&
8669 VerifyField<uint8_t>(verifier, VT_VALIDATE_INDICES, 1) &&
8670 verifier.EndTable();
8671 }
8673 void UnPackTo(SparseToDenseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8674 static flatbuffers::Offset<SparseToDenseOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8675};
8676
8678 typedef SparseToDenseOptions Table;
8680 flatbuffers::uoffset_t start_;
8681 void add_validate_indices(bool validate_indices) {
8682 fbb_.AddElement<uint8_t>(SparseToDenseOptions::VT_VALIDATE_INDICES, static_cast<uint8_t>(validate_indices), 0);
8683 }
8685 : fbb_(_fbb) {
8686 start_ = fbb_.StartTable();
8687 }
8688 flatbuffers::Offset<SparseToDenseOptions> Finish() {
8689 const auto end = fbb_.EndTable(start_);
8690 auto o = flatbuffers::Offset<SparseToDenseOptions>(end);
8691 return o;
8692 }
8693};
8694
8695inline flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(
8697 bool validate_indices = false) {
8699 builder_.add_validate_indices(validate_indices);
8700 return builder_.Finish();
8701}
8702
8703flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8704
8705struct EqualOptionsT : public flatbuffers::NativeTable {
8706 typedef EqualOptions TableType;
8707};
8708
8709struct EqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8712 bool Verify(flatbuffers::Verifier &verifier) const {
8713 return VerifyTableStart(verifier) &&
8714 verifier.EndTable();
8715 }
8716 EqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8717 void UnPackTo(EqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8718 static flatbuffers::Offset<EqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8719};
8720
8721struct EqualOptionsBuilder {
8722 typedef EqualOptions Table;
8724 flatbuffers::uoffset_t start_;
8726 : fbb_(_fbb) {
8727 start_ = fbb_.StartTable();
8728 }
8729 flatbuffers::Offset<EqualOptions> Finish() {
8730 const auto end = fbb_.EndTable(start_);
8731 auto o = flatbuffers::Offset<EqualOptions>(end);
8732 return o;
8733 }
8734};
8735
8736inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(
8739 return builder_.Finish();
8740}
8741
8742flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8743
8744struct NotEqualOptionsT : public flatbuffers::NativeTable {
8745 typedef NotEqualOptions TableType;
8746};
8747
8748struct NotEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8751 bool Verify(flatbuffers::Verifier &verifier) const {
8752 return VerifyTableStart(verifier) &&
8753 verifier.EndTable();
8754 }
8756 void UnPackTo(NotEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8757 static flatbuffers::Offset<NotEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8758};
8759
8761 typedef NotEqualOptions Table;
8763 flatbuffers::uoffset_t start_;
8765 : fbb_(_fbb) {
8766 start_ = fbb_.StartTable();
8767 }
8768 flatbuffers::Offset<NotEqualOptions> Finish() {
8769 const auto end = fbb_.EndTable(start_);
8770 auto o = flatbuffers::Offset<NotEqualOptions>(end);
8771 return o;
8772 }
8773};
8774
8775inline flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(
8778 return builder_.Finish();
8779}
8780
8781flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8782
8783struct ShapeOptionsT : public flatbuffers::NativeTable {
8784 typedef ShapeOptions TableType;
8786};
8787
8788struct ShapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8791 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8792 VT_OUT_TYPE = 4
8793 };
8795 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_OUT_TYPE, 0));
8796 }
8797 bool Verify(flatbuffers::Verifier &verifier) const {
8798 return VerifyTableStart(verifier) &&
8799 VerifyField<int8_t>(verifier, VT_OUT_TYPE, 1) &&
8800 verifier.EndTable();
8801 }
8802 ShapeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8803 void UnPackTo(ShapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8804 static flatbuffers::Offset<ShapeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8805};
8806
8807struct ShapeOptionsBuilder {
8808 typedef ShapeOptions Table;
8810 flatbuffers::uoffset_t start_;
8812 fbb_.AddElement<int8_t>(ShapeOptions::VT_OUT_TYPE, static_cast<int8_t>(out_type), 0);
8813 }
8815 : fbb_(_fbb) {
8816 start_ = fbb_.StartTable();
8817 }
8818 flatbuffers::Offset<ShapeOptions> Finish() {
8819 const auto end = fbb_.EndTable(start_);
8820 auto o = flatbuffers::Offset<ShapeOptions>(end);
8821 return o;
8822 }
8823};
8824
8825inline flatbuffers::Offset<ShapeOptions> CreateShapeOptions(
8829 builder_.add_out_type(out_type);
8830 return builder_.Finish();
8831}
8832
8833flatbuffers::Offset<ShapeOptions> CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8834
8835struct RankOptionsT : public flatbuffers::NativeTable {
8836 typedef RankOptions TableType;
8837};
8838
8839struct RankOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8842 bool Verify(flatbuffers::Verifier &verifier) const {
8843 return VerifyTableStart(verifier) &&
8844 verifier.EndTable();
8845 }
8846 RankOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8847 void UnPackTo(RankOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8848 static flatbuffers::Offset<RankOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8849};
8850
8851struct RankOptionsBuilder {
8852 typedef RankOptions Table;
8854 flatbuffers::uoffset_t start_;
8856 : fbb_(_fbb) {
8857 start_ = fbb_.StartTable();
8858 }
8859 flatbuffers::Offset<RankOptions> Finish() {
8860 const auto end = fbb_.EndTable(start_);
8861 auto o = flatbuffers::Offset<RankOptions>(end);
8862 return o;
8863 }
8864};
8865
8866inline flatbuffers::Offset<RankOptions> CreateRankOptions(
8869 return builder_.Finish();
8870}
8871
8872flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8873
8874struct PowOptionsT : public flatbuffers::NativeTable {
8875 typedef PowOptions TableType;
8876};
8877
8878struct PowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8881 bool Verify(flatbuffers::Verifier &verifier) const {
8882 return VerifyTableStart(verifier) &&
8883 verifier.EndTable();
8884 }
8885 PowOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8886 void UnPackTo(PowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8887 static flatbuffers::Offset<PowOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8888};
8889
8890struct PowOptionsBuilder {
8891 typedef PowOptions Table;
8893 flatbuffers::uoffset_t start_;
8895 : fbb_(_fbb) {
8896 start_ = fbb_.StartTable();
8897 }
8898 flatbuffers::Offset<PowOptions> Finish() {
8899 const auto end = fbb_.EndTable(start_);
8900 auto o = flatbuffers::Offset<PowOptions>(end);
8901 return o;
8902 }
8903};
8904
8905inline flatbuffers::Offset<PowOptions> CreatePowOptions(
8908 return builder_.Finish();
8909}
8910
8911flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8912
8913struct FakeQuantOptionsT : public flatbuffers::NativeTable {
8914 typedef FakeQuantOptions TableType;
8915 float min = 0.0f;
8916 float max = 0.0f;
8917 int32_t num_bits = 0;
8918 bool narrow_range = false;
8919};
8920
8921struct FakeQuantOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
8924 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
8925 VT_MIN = 4,
8926 VT_MAX = 6,
8928 VT_NARROW_RANGE = 10
8929 };
8930 float min() const {
8931 return GetField<float>(VT_MIN, 0.0f);
8932 }
8933 float max() const {
8934 return GetField<float>(VT_MAX, 0.0f);
8935 }
8936 int32_t num_bits() const {
8937 return GetField<int32_t>(VT_NUM_BITS, 0);
8938 }
8939 bool narrow_range() const {
8940 return GetField<uint8_t>(VT_NARROW_RANGE, 0) != 0;
8941 }
8942 bool Verify(flatbuffers::Verifier &verifier) const {
8943 return VerifyTableStart(verifier) &&
8944 VerifyField<float>(verifier, VT_MIN, 4) &&
8945 VerifyField<float>(verifier, VT_MAX, 4) &&
8946 VerifyField<int32_t>(verifier, VT_NUM_BITS, 4) &&
8947 VerifyField<uint8_t>(verifier, VT_NARROW_RANGE, 1) &&
8948 verifier.EndTable();
8949 }
8951 void UnPackTo(FakeQuantOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
8952 static flatbuffers::Offset<FakeQuantOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8953};
8954
8956 typedef FakeQuantOptions Table;
8958 flatbuffers::uoffset_t start_;
8959 void add_min(float min) {
8960 fbb_.AddElement<float>(FakeQuantOptions::VT_MIN, min, 0.0f);
8961 }
8962 void add_max(float max) {
8963 fbb_.AddElement<float>(FakeQuantOptions::VT_MAX, max, 0.0f);
8964 }
8965 void add_num_bits(int32_t num_bits) {
8966 fbb_.AddElement<int32_t>(FakeQuantOptions::VT_NUM_BITS, num_bits, 0);
8967 }
8968 void add_narrow_range(bool narrow_range) {
8969 fbb_.AddElement<uint8_t>(FakeQuantOptions::VT_NARROW_RANGE, static_cast<uint8_t>(narrow_range), 0);
8970 }
8972 : fbb_(_fbb) {
8973 start_ = fbb_.StartTable();
8974 }
8975 flatbuffers::Offset<FakeQuantOptions> Finish() {
8976 const auto end = fbb_.EndTable(start_);
8977 auto o = flatbuffers::Offset<FakeQuantOptions>(end);
8978 return o;
8979 }
8980};
8981
8982inline flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(
8984 float min = 0.0f,
8985 float max = 0.0f,
8986 int32_t num_bits = 0,
8987 bool narrow_range = false) {
8989 builder_.add_num_bits(num_bits);
8990 builder_.add_max(max);
8991 builder_.add_min(min);
8992 builder_.add_narrow_range(narrow_range);
8993 return builder_.Finish();
8994}
8995
8996flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
8997
8998struct PackOptionsT : public flatbuffers::NativeTable {
8999 typedef PackOptions TableType;
9000 int32_t values_count = 0;
9001 int32_t axis = 0;
9002};
9003
9004struct PackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9007 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9009 VT_AXIS = 6
9010 };
9011 int32_t values_count() const {
9012 return GetField<int32_t>(VT_VALUES_COUNT, 0);
9013 }
9014 int32_t axis() const {
9015 return GetField<int32_t>(VT_AXIS, 0);
9016 }
9017 bool Verify(flatbuffers::Verifier &verifier) const {
9018 return VerifyTableStart(verifier) &&
9019 VerifyField<int32_t>(verifier, VT_VALUES_COUNT, 4) &&
9020 VerifyField<int32_t>(verifier, VT_AXIS, 4) &&
9021 verifier.EndTable();
9022 }
9023 PackOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9024 void UnPackTo(PackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9025 static flatbuffers::Offset<PackOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9026};
9027
9028struct PackOptionsBuilder {
9029 typedef PackOptions Table;
9031 flatbuffers::uoffset_t start_;
9032 void add_values_count(int32_t values_count) {
9033 fbb_.AddElement<int32_t>(PackOptions::VT_VALUES_COUNT, values_count, 0);
9034 }
9035 void add_axis(int32_t axis) {
9036 fbb_.AddElement<int32_t>(PackOptions::VT_AXIS, axis, 0);
9037 }
9039 : fbb_(_fbb) {
9040 start_ = fbb_.StartTable();
9041 }
9042 flatbuffers::Offset<PackOptions> Finish() {
9043 const auto end = fbb_.EndTable(start_);
9044 auto o = flatbuffers::Offset<PackOptions>(end);
9045 return o;
9046 }
9047};
9048
9049inline flatbuffers::Offset<PackOptions> CreatePackOptions(
9051 int32_t values_count = 0,
9052 int32_t axis = 0) {
9054 builder_.add_axis(axis);
9055 builder_.add_values_count(values_count);
9056 return builder_.Finish();
9057}
9058
9059flatbuffers::Offset<PackOptions> CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9060
9061struct LogicalOrOptionsT : public flatbuffers::NativeTable {
9062 typedef LogicalOrOptions TableType;
9063};
9064
9065struct LogicalOrOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9068 bool Verify(flatbuffers::Verifier &verifier) const {
9069 return VerifyTableStart(verifier) &&
9070 verifier.EndTable();
9071 }
9073 void UnPackTo(LogicalOrOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9074 static flatbuffers::Offset<LogicalOrOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9075};
9076
9078 typedef LogicalOrOptions Table;
9080 flatbuffers::uoffset_t start_;
9082 : fbb_(_fbb) {
9083 start_ = fbb_.StartTable();
9084 }
9085 flatbuffers::Offset<LogicalOrOptions> Finish() {
9086 const auto end = fbb_.EndTable(start_);
9087 auto o = flatbuffers::Offset<LogicalOrOptions>(end);
9088 return o;
9089 }
9090};
9091
9092inline flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(
9095 return builder_.Finish();
9096}
9097
9098flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9099
9100struct OneHotOptionsT : public flatbuffers::NativeTable {
9101 typedef OneHotOptions TableType;
9102 int32_t axis = 0;
9103};
9104
9105struct OneHotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9108 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9109 VT_AXIS = 4
9110 };
9111 int32_t axis() const {
9112 return GetField<int32_t>(VT_AXIS, 0);
9113 }
9114 bool Verify(flatbuffers::Verifier &verifier) const {
9115 return VerifyTableStart(verifier) &&
9116 VerifyField<int32_t>(verifier, VT_AXIS, 4) &&
9117 verifier.EndTable();
9118 }
9119 OneHotOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9120 void UnPackTo(OneHotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9121 static flatbuffers::Offset<OneHotOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9122};
9123
9124struct OneHotOptionsBuilder {
9125 typedef OneHotOptions Table;
9127 flatbuffers::uoffset_t start_;
9128 void add_axis(int32_t axis) {
9129 fbb_.AddElement<int32_t>(OneHotOptions::VT_AXIS, axis, 0);
9130 }
9132 : fbb_(_fbb) {
9133 start_ = fbb_.StartTable();
9134 }
9135 flatbuffers::Offset<OneHotOptions> Finish() {
9136 const auto end = fbb_.EndTable(start_);
9137 auto o = flatbuffers::Offset<OneHotOptions>(end);
9138 return o;
9139 }
9140};
9141
9142inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(
9144 int32_t axis = 0) {
9146 builder_.add_axis(axis);
9147 return builder_.Finish();
9148}
9149
9150flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9151
9152struct AbsOptionsT : public flatbuffers::NativeTable {
9153 typedef AbsOptions TableType;
9154};
9155
9156struct AbsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9159 bool Verify(flatbuffers::Verifier &verifier) const {
9160 return VerifyTableStart(verifier) &&
9161 verifier.EndTable();
9162 }
9163 AbsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9164 void UnPackTo(AbsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9165 static flatbuffers::Offset<AbsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9166};
9167
9168struct AbsOptionsBuilder {
9169 typedef AbsOptions Table;
9171 flatbuffers::uoffset_t start_;
9173 : fbb_(_fbb) {
9174 start_ = fbb_.StartTable();
9175 }
9176 flatbuffers::Offset<AbsOptions> Finish() {
9177 const auto end = fbb_.EndTable(start_);
9178 auto o = flatbuffers::Offset<AbsOptions>(end);
9179 return o;
9180 }
9181};
9182
9183inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(
9186 return builder_.Finish();
9187}
9188
9189flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9190
9191struct HardSwishOptionsT : public flatbuffers::NativeTable {
9192 typedef HardSwishOptions TableType;
9193};
9194
9195struct HardSwishOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9198 bool Verify(flatbuffers::Verifier &verifier) const {
9199 return VerifyTableStart(verifier) &&
9200 verifier.EndTable();
9201 }
9203 void UnPackTo(HardSwishOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9204 static flatbuffers::Offset<HardSwishOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9205};
9206
9208 typedef HardSwishOptions Table;
9210 flatbuffers::uoffset_t start_;
9212 : fbb_(_fbb) {
9213 start_ = fbb_.StartTable();
9214 }
9215 flatbuffers::Offset<HardSwishOptions> Finish() {
9216 const auto end = fbb_.EndTable(start_);
9217 auto o = flatbuffers::Offset<HardSwishOptions>(end);
9218 return o;
9219 }
9220};
9221
9222inline flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(
9225 return builder_.Finish();
9226}
9227
9228flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9229
9230struct LogicalAndOptionsT : public flatbuffers::NativeTable {
9231 typedef LogicalAndOptions TableType;
9232};
9233
9234struct LogicalAndOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9237 bool Verify(flatbuffers::Verifier &verifier) const {
9238 return VerifyTableStart(verifier) &&
9239 verifier.EndTable();
9240 }
9242 void UnPackTo(LogicalAndOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9243 static flatbuffers::Offset<LogicalAndOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9244};
9245
9247 typedef LogicalAndOptions Table;
9249 flatbuffers::uoffset_t start_;
9251 : fbb_(_fbb) {
9252 start_ = fbb_.StartTable();
9253 }
9254 flatbuffers::Offset<LogicalAndOptions> Finish() {
9255 const auto end = fbb_.EndTable(start_);
9256 auto o = flatbuffers::Offset<LogicalAndOptions>(end);
9257 return o;
9258 }
9259};
9260
9261inline flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(
9264 return builder_.Finish();
9265}
9266
9267flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9268
9269struct LogicalNotOptionsT : public flatbuffers::NativeTable {
9270 typedef LogicalNotOptions TableType;
9271};
9272
9273struct LogicalNotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9276 bool Verify(flatbuffers::Verifier &verifier) const {
9277 return VerifyTableStart(verifier) &&
9278 verifier.EndTable();
9279 }
9281 void UnPackTo(LogicalNotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9282 static flatbuffers::Offset<LogicalNotOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9283};
9284
9286 typedef LogicalNotOptions Table;
9288 flatbuffers::uoffset_t start_;
9290 : fbb_(_fbb) {
9291 start_ = fbb_.StartTable();
9292 }
9293 flatbuffers::Offset<LogicalNotOptions> Finish() {
9294 const auto end = fbb_.EndTable(start_);
9295 auto o = flatbuffers::Offset<LogicalNotOptions>(end);
9296 return o;
9297 }
9298};
9299
9300inline flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(
9303 return builder_.Finish();
9304}
9305
9306flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9307
9308struct UnpackOptionsT : public flatbuffers::NativeTable {
9309 typedef UnpackOptions TableType;
9310 int32_t num = 0;
9311 int32_t axis = 0;
9312};
9313
9314struct UnpackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9317 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9319 VT_AXIS = 6
9320 };
9321 int32_t num() const {
9322 return GetField<int32_t>(VT_NUM, 0);
9323 }
9324 int32_t axis() const {
9325 return GetField<int32_t>(VT_AXIS, 0);
9326 }
9327 bool Verify(flatbuffers::Verifier &verifier) const {
9328 return VerifyTableStart(verifier) &&
9329 VerifyField<int32_t>(verifier, VT_NUM, 4) &&
9330 VerifyField<int32_t>(verifier, VT_AXIS, 4) &&
9331 verifier.EndTable();
9332 }
9333 UnpackOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9334 void UnPackTo(UnpackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9335 static flatbuffers::Offset<UnpackOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9336};
9337
9338struct UnpackOptionsBuilder {
9339 typedef UnpackOptions Table;
9341 flatbuffers::uoffset_t start_;
9342 void add_num(int32_t num) {
9343 fbb_.AddElement<int32_t>(UnpackOptions::VT_NUM, num, 0);
9344 }
9345 void add_axis(int32_t axis) {
9346 fbb_.AddElement<int32_t>(UnpackOptions::VT_AXIS, axis, 0);
9347 }
9349 : fbb_(_fbb) {
9350 start_ = fbb_.StartTable();
9351 }
9352 flatbuffers::Offset<UnpackOptions> Finish() {
9353 const auto end = fbb_.EndTable(start_);
9354 auto o = flatbuffers::Offset<UnpackOptions>(end);
9355 return o;
9356 }
9357};
9358
9359inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(
9361 int32_t num = 0,
9362 int32_t axis = 0) {
9364 builder_.add_axis(axis);
9365 builder_.add_num(num);
9366 return builder_.Finish();
9367}
9368
9369flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9370
9371struct FloorDivOptionsT : public flatbuffers::NativeTable {
9372 typedef FloorDivOptions TableType;
9373};
9374
9375struct FloorDivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9378 bool Verify(flatbuffers::Verifier &verifier) const {
9379 return VerifyTableStart(verifier) &&
9380 verifier.EndTable();
9381 }
9383 void UnPackTo(FloorDivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9384 static flatbuffers::Offset<FloorDivOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9385};
9386
9388 typedef FloorDivOptions Table;
9390 flatbuffers::uoffset_t start_;
9392 : fbb_(_fbb) {
9393 start_ = fbb_.StartTable();
9394 }
9395 flatbuffers::Offset<FloorDivOptions> Finish() {
9396 const auto end = fbb_.EndTable(start_);
9397 auto o = flatbuffers::Offset<FloorDivOptions>(end);
9398 return o;
9399 }
9400};
9401
9402inline flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(
9405 return builder_.Finish();
9406}
9407
9408flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9409
9410struct SquareOptionsT : public flatbuffers::NativeTable {
9411 typedef SquareOptions TableType;
9412};
9413
9414struct SquareOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9417 bool Verify(flatbuffers::Verifier &verifier) const {
9418 return VerifyTableStart(verifier) &&
9419 verifier.EndTable();
9420 }
9421 SquareOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9422 void UnPackTo(SquareOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9423 static flatbuffers::Offset<SquareOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9424};
9425
9426struct SquareOptionsBuilder {
9427 typedef SquareOptions Table;
9429 flatbuffers::uoffset_t start_;
9431 : fbb_(_fbb) {
9432 start_ = fbb_.StartTable();
9433 }
9434 flatbuffers::Offset<SquareOptions> Finish() {
9435 const auto end = fbb_.EndTable(start_);
9436 auto o = flatbuffers::Offset<SquareOptions>(end);
9437 return o;
9438 }
9439};
9440
9441inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(
9444 return builder_.Finish();
9445}
9446
9447flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9448
9449struct ZerosLikeOptionsT : public flatbuffers::NativeTable {
9450 typedef ZerosLikeOptions TableType;
9451};
9452
9453struct ZerosLikeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9456 bool Verify(flatbuffers::Verifier &verifier) const {
9457 return VerifyTableStart(verifier) &&
9458 verifier.EndTable();
9459 }
9461 void UnPackTo(ZerosLikeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9462 static flatbuffers::Offset<ZerosLikeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9463};
9464
9466 typedef ZerosLikeOptions Table;
9468 flatbuffers::uoffset_t start_;
9470 : fbb_(_fbb) {
9471 start_ = fbb_.StartTable();
9472 }
9473 flatbuffers::Offset<ZerosLikeOptions> Finish() {
9474 const auto end = fbb_.EndTable(start_);
9475 auto o = flatbuffers::Offset<ZerosLikeOptions>(end);
9476 return o;
9477 }
9478};
9479
9480inline flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(
9483 return builder_.Finish();
9484}
9485
9486flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9487
9488struct FillOptionsT : public flatbuffers::NativeTable {
9489 typedef FillOptions TableType;
9490};
9491
9492struct FillOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9495 bool Verify(flatbuffers::Verifier &verifier) const {
9496 return VerifyTableStart(verifier) &&
9497 verifier.EndTable();
9498 }
9499 FillOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9500 void UnPackTo(FillOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9501 static flatbuffers::Offset<FillOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9502};
9503
9504struct FillOptionsBuilder {
9505 typedef FillOptions Table;
9507 flatbuffers::uoffset_t start_;
9509 : fbb_(_fbb) {
9510 start_ = fbb_.StartTable();
9511 }
9512 flatbuffers::Offset<FillOptions> Finish() {
9513 const auto end = fbb_.EndTable(start_);
9514 auto o = flatbuffers::Offset<FillOptions>(end);
9515 return o;
9516 }
9517};
9518
9519inline flatbuffers::Offset<FillOptions> CreateFillOptions(
9522 return builder_.Finish();
9523}
9524
9525flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9526
9527struct FloorModOptionsT : public flatbuffers::NativeTable {
9528 typedef FloorModOptions TableType;
9529};
9530
9531struct FloorModOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9534 bool Verify(flatbuffers::Verifier &verifier) const {
9535 return VerifyTableStart(verifier) &&
9536 verifier.EndTable();
9537 }
9539 void UnPackTo(FloorModOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9540 static flatbuffers::Offset<FloorModOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9541};
9542
9544 typedef FloorModOptions Table;
9546 flatbuffers::uoffset_t start_;
9548 : fbb_(_fbb) {
9549 start_ = fbb_.StartTable();
9550 }
9551 flatbuffers::Offset<FloorModOptions> Finish() {
9552 const auto end = fbb_.EndTable(start_);
9553 auto o = flatbuffers::Offset<FloorModOptions>(end);
9554 return o;
9555 }
9556};
9557
9558inline flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(
9561 return builder_.Finish();
9562}
9563
9564flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9565
9566struct RangeOptionsT : public flatbuffers::NativeTable {
9567 typedef RangeOptions TableType;
9568};
9569
9570struct RangeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9573 bool Verify(flatbuffers::Verifier &verifier) const {
9574 return VerifyTableStart(verifier) &&
9575 verifier.EndTable();
9576 }
9577 RangeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9578 void UnPackTo(RangeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9579 static flatbuffers::Offset<RangeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9580};
9581
9582struct RangeOptionsBuilder {
9583 typedef RangeOptions Table;
9585 flatbuffers::uoffset_t start_;
9587 : fbb_(_fbb) {
9588 start_ = fbb_.StartTable();
9589 }
9590 flatbuffers::Offset<RangeOptions> Finish() {
9591 const auto end = fbb_.EndTable(start_);
9592 auto o = flatbuffers::Offset<RangeOptions>(end);
9593 return o;
9594 }
9595};
9596
9597inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(
9600 return builder_.Finish();
9601}
9602
9603flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9604
9605struct LeakyReluOptionsT : public flatbuffers::NativeTable {
9606 typedef LeakyReluOptions TableType;
9607 float alpha = 0.0f;
9608};
9609
9610struct LeakyReluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9613 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9614 VT_ALPHA = 4
9615 };
9616 float alpha() const {
9617 return GetField<float>(VT_ALPHA, 0.0f);
9618 }
9619 bool Verify(flatbuffers::Verifier &verifier) const {
9620 return VerifyTableStart(verifier) &&
9621 VerifyField<float>(verifier, VT_ALPHA, 4) &&
9622 verifier.EndTable();
9623 }
9625 void UnPackTo(LeakyReluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9626 static flatbuffers::Offset<LeakyReluOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9627};
9628
9630 typedef LeakyReluOptions Table;
9632 flatbuffers::uoffset_t start_;
9633 void add_alpha(float alpha) {
9634 fbb_.AddElement<float>(LeakyReluOptions::VT_ALPHA, alpha, 0.0f);
9635 }
9637 : fbb_(_fbb) {
9638 start_ = fbb_.StartTable();
9639 }
9640 flatbuffers::Offset<LeakyReluOptions> Finish() {
9641 const auto end = fbb_.EndTable(start_);
9642 auto o = flatbuffers::Offset<LeakyReluOptions>(end);
9643 return o;
9644 }
9645};
9646
9647inline flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(
9649 float alpha = 0.0f) {
9651 builder_.add_alpha(alpha);
9652 return builder_.Finish();
9653}
9654
9655flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9656
9657struct SquaredDifferenceOptionsT : public flatbuffers::NativeTable {
9658 typedef SquaredDifferenceOptions TableType;
9659};
9660
9661struct SquaredDifferenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9664 bool Verify(flatbuffers::Verifier &verifier) const {
9665 return VerifyTableStart(verifier) &&
9666 verifier.EndTable();
9667 }
9669 void UnPackTo(SquaredDifferenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9670 static flatbuffers::Offset<SquaredDifferenceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9671};
9672
9674 typedef SquaredDifferenceOptions Table;
9676 flatbuffers::uoffset_t start_;
9678 : fbb_(_fbb) {
9679 start_ = fbb_.StartTable();
9680 }
9681 flatbuffers::Offset<SquaredDifferenceOptions> Finish() {
9682 const auto end = fbb_.EndTable(start_);
9683 auto o = flatbuffers::Offset<SquaredDifferenceOptions>(end);
9684 return o;
9685 }
9686};
9687
9688inline flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(
9691 return builder_.Finish();
9692}
9693
9694flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9695
9696struct MirrorPadOptionsT : public flatbuffers::NativeTable {
9697 typedef MirrorPadOptions TableType;
9699};
9700
9701struct MirrorPadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9704 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9705 VT_MODE = 4
9706 };
9708 return static_cast<tflite::MirrorPadMode>(GetField<int8_t>(VT_MODE, 0));
9709 }
9710 bool Verify(flatbuffers::Verifier &verifier) const {
9711 return VerifyTableStart(verifier) &&
9712 VerifyField<int8_t>(verifier, VT_MODE, 1) &&
9713 verifier.EndTable();
9714 }
9716 void UnPackTo(MirrorPadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9717 static flatbuffers::Offset<MirrorPadOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9718};
9719
9721 typedef MirrorPadOptions Table;
9723 flatbuffers::uoffset_t start_;
9725 fbb_.AddElement<int8_t>(MirrorPadOptions::VT_MODE, static_cast<int8_t>(mode), 0);
9726 }
9728 : fbb_(_fbb) {
9729 start_ = fbb_.StartTable();
9730 }
9731 flatbuffers::Offset<MirrorPadOptions> Finish() {
9732 const auto end = fbb_.EndTable(start_);
9733 auto o = flatbuffers::Offset<MirrorPadOptions>(end);
9734 return o;
9735 }
9736};
9737
9738inline flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(
9742 builder_.add_mode(mode);
9743 return builder_.Finish();
9744}
9745
9746flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9747
9748struct UniqueOptionsT : public flatbuffers::NativeTable {
9749 typedef UniqueOptions TableType;
9751};
9752
9753struct UniqueOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9756 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9757 VT_IDX_OUT_TYPE = 4
9758 };
9760 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_IDX_OUT_TYPE, 2));
9761 }
9762 bool Verify(flatbuffers::Verifier &verifier) const {
9763 return VerifyTableStart(verifier) &&
9764 VerifyField<int8_t>(verifier, VT_IDX_OUT_TYPE, 1) &&
9765 verifier.EndTable();
9766 }
9767 UniqueOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9768 void UnPackTo(UniqueOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9769 static flatbuffers::Offset<UniqueOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9770};
9771
9772struct UniqueOptionsBuilder {
9773 typedef UniqueOptions Table;
9775 flatbuffers::uoffset_t start_;
9777 fbb_.AddElement<int8_t>(UniqueOptions::VT_IDX_OUT_TYPE, static_cast<int8_t>(idx_out_type), 2);
9778 }
9780 : fbb_(_fbb) {
9781 start_ = fbb_.StartTable();
9782 }
9783 flatbuffers::Offset<UniqueOptions> Finish() {
9784 const auto end = fbb_.EndTable(start_);
9785 auto o = flatbuffers::Offset<UniqueOptions>(end);
9786 return o;
9787 }
9788};
9789
9790inline flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(
9794 builder_.add_idx_out_type(idx_out_type);
9795 return builder_.Finish();
9796}
9797
9798flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9799
9800struct ReverseV2OptionsT : public flatbuffers::NativeTable {
9801 typedef ReverseV2Options TableType;
9802};
9803
9804struct ReverseV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9807 bool Verify(flatbuffers::Verifier &verifier) const {
9808 return VerifyTableStart(verifier) &&
9809 verifier.EndTable();
9810 }
9812 void UnPackTo(ReverseV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9813 static flatbuffers::Offset<ReverseV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9814};
9815
9817 typedef ReverseV2Options Table;
9819 flatbuffers::uoffset_t start_;
9821 : fbb_(_fbb) {
9822 start_ = fbb_.StartTable();
9823 }
9824 flatbuffers::Offset<ReverseV2Options> Finish() {
9825 const auto end = fbb_.EndTable(start_);
9826 auto o = flatbuffers::Offset<ReverseV2Options>(end);
9827 return o;
9828 }
9829};
9830
9831inline flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(
9834 return builder_.Finish();
9835}
9836
9837flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9838
9839struct AddNOptionsT : public flatbuffers::NativeTable {
9840 typedef AddNOptions TableType;
9841};
9842
9843struct AddNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9846 bool Verify(flatbuffers::Verifier &verifier) const {
9847 return VerifyTableStart(verifier) &&
9848 verifier.EndTable();
9849 }
9850 AddNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9851 void UnPackTo(AddNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9852 static flatbuffers::Offset<AddNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9853};
9854
9855struct AddNOptionsBuilder {
9856 typedef AddNOptions Table;
9858 flatbuffers::uoffset_t start_;
9860 : fbb_(_fbb) {
9861 start_ = fbb_.StartTable();
9862 }
9863 flatbuffers::Offset<AddNOptions> Finish() {
9864 const auto end = fbb_.EndTable(start_);
9865 auto o = flatbuffers::Offset<AddNOptions>(end);
9866 return o;
9867 }
9868};
9869
9870inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(
9873 return builder_.Finish();
9874}
9875
9876flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9877
9878struct GatherNdOptionsT : public flatbuffers::NativeTable {
9879 typedef GatherNdOptions TableType;
9880};
9881
9882struct GatherNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9885 bool Verify(flatbuffers::Verifier &verifier) const {
9886 return VerifyTableStart(verifier) &&
9887 verifier.EndTable();
9888 }
9890 void UnPackTo(GatherNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9891 static flatbuffers::Offset<GatherNdOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9892};
9893
9895 typedef GatherNdOptions Table;
9897 flatbuffers::uoffset_t start_;
9899 : fbb_(_fbb) {
9900 start_ = fbb_.StartTable();
9901 }
9902 flatbuffers::Offset<GatherNdOptions> Finish() {
9903 const auto end = fbb_.EndTable(start_);
9904 auto o = flatbuffers::Offset<GatherNdOptions>(end);
9905 return o;
9906 }
9907};
9908
9909inline flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(
9912 return builder_.Finish();
9913}
9914
9915flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9916
9917struct WhereOptionsT : public flatbuffers::NativeTable {
9918 typedef WhereOptions TableType;
9919};
9920
9921struct WhereOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9924 bool Verify(flatbuffers::Verifier &verifier) const {
9925 return VerifyTableStart(verifier) &&
9926 verifier.EndTable();
9927 }
9928 WhereOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9929 void UnPackTo(WhereOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9930 static flatbuffers::Offset<WhereOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9931};
9932
9933struct WhereOptionsBuilder {
9934 typedef WhereOptions Table;
9936 flatbuffers::uoffset_t start_;
9938 : fbb_(_fbb) {
9939 start_ = fbb_.StartTable();
9940 }
9941 flatbuffers::Offset<WhereOptions> Finish() {
9942 const auto end = fbb_.EndTable(start_);
9943 auto o = flatbuffers::Offset<WhereOptions>(end);
9944 return o;
9945 }
9946};
9947
9948inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(
9951 return builder_.Finish();
9952}
9953
9954flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9955
9956struct ReverseSequenceOptionsT : public flatbuffers::NativeTable {
9957 typedef ReverseSequenceOptions TableType;
9958 int32_t seq_dim = 0;
9959 int32_t batch_dim = 0;
9960};
9961
9962struct ReverseSequenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
9965 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
9967 VT_BATCH_DIM = 6
9968 };
9969 int32_t seq_dim() const {
9970 return GetField<int32_t>(VT_SEQ_DIM, 0);
9971 }
9972 int32_t batch_dim() const {
9973 return GetField<int32_t>(VT_BATCH_DIM, 0);
9974 }
9975 bool Verify(flatbuffers::Verifier &verifier) const {
9976 return VerifyTableStart(verifier) &&
9977 VerifyField<int32_t>(verifier, VT_SEQ_DIM, 4) &&
9978 VerifyField<int32_t>(verifier, VT_BATCH_DIM, 4) &&
9979 verifier.EndTable();
9980 }
9982 void UnPackTo(ReverseSequenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
9983 static flatbuffers::Offset<ReverseSequenceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
9984};
9985
9987 typedef ReverseSequenceOptions Table;
9989 flatbuffers::uoffset_t start_;
9990 void add_seq_dim(int32_t seq_dim) {
9991 fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_SEQ_DIM, seq_dim, 0);
9992 }
9993 void add_batch_dim(int32_t batch_dim) {
9994 fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_BATCH_DIM, batch_dim, 0);
9995 }
9997 : fbb_(_fbb) {
9998 start_ = fbb_.StartTable();
9999 }
10000 flatbuffers::Offset<ReverseSequenceOptions> Finish() {
10001 const auto end = fbb_.EndTable(start_);
10002 auto o = flatbuffers::Offset<ReverseSequenceOptions>(end);
10003 return o;
10004 }
10005};
10006
10007inline flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(
10009 int32_t seq_dim = 0,
10010 int32_t batch_dim = 0) {
10012 builder_.add_batch_dim(batch_dim);
10013 builder_.add_seq_dim(seq_dim);
10014 return builder_.Finish();
10015}
10016
10017flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10018
10019struct MatrixDiagOptionsT : public flatbuffers::NativeTable {
10020 typedef MatrixDiagOptions TableType;
10021};
10022
10023struct MatrixDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10026 bool Verify(flatbuffers::Verifier &verifier) const {
10027 return VerifyTableStart(verifier) &&
10028 verifier.EndTable();
10029 }
10031 void UnPackTo(MatrixDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10032 static flatbuffers::Offset<MatrixDiagOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10033};
10034
10036 typedef MatrixDiagOptions Table;
10038 flatbuffers::uoffset_t start_;
10040 : fbb_(_fbb) {
10041 start_ = fbb_.StartTable();
10042 }
10043 flatbuffers::Offset<MatrixDiagOptions> Finish() {
10044 const auto end = fbb_.EndTable(start_);
10045 auto o = flatbuffers::Offset<MatrixDiagOptions>(end);
10046 return o;
10047 }
10048};
10049
10050inline flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(
10053 return builder_.Finish();
10054}
10055
10056flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10057
10058struct QuantizeOptionsT : public flatbuffers::NativeTable {
10059 typedef QuantizeOptions TableType;
10060};
10061
10062struct QuantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10065 bool Verify(flatbuffers::Verifier &verifier) const {
10066 return VerifyTableStart(verifier) &&
10067 verifier.EndTable();
10068 }
10070 void UnPackTo(QuantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10071 static flatbuffers::Offset<QuantizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10072};
10073
10075 typedef QuantizeOptions Table;
10077 flatbuffers::uoffset_t start_;
10079 : fbb_(_fbb) {
10080 start_ = fbb_.StartTable();
10081 }
10082 flatbuffers::Offset<QuantizeOptions> Finish() {
10083 const auto end = fbb_.EndTable(start_);
10084 auto o = flatbuffers::Offset<QuantizeOptions>(end);
10085 return o;
10086 }
10087};
10088
10089inline flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(
10092 return builder_.Finish();
10093}
10094
10095flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10096
10097struct MatrixSetDiagOptionsT : public flatbuffers::NativeTable {
10098 typedef MatrixSetDiagOptions TableType;
10099};
10100
10101struct MatrixSetDiagOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10104 bool Verify(flatbuffers::Verifier &verifier) const {
10105 return VerifyTableStart(verifier) &&
10106 verifier.EndTable();
10107 }
10109 void UnPackTo(MatrixSetDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10110 static flatbuffers::Offset<MatrixSetDiagOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10111};
10112
10114 typedef MatrixSetDiagOptions Table;
10116 flatbuffers::uoffset_t start_;
10118 : fbb_(_fbb) {
10119 start_ = fbb_.StartTable();
10120 }
10121 flatbuffers::Offset<MatrixSetDiagOptions> Finish() {
10122 const auto end = fbb_.EndTable(start_);
10123 auto o = flatbuffers::Offset<MatrixSetDiagOptions>(end);
10124 return o;
10125 }
10126};
10127
10128inline flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(
10131 return builder_.Finish();
10132}
10133
10134flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10135
10136struct IfOptionsT : public flatbuffers::NativeTable {
10137 typedef IfOptions TableType;
10140};
10141
10142struct IfOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10145 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10147 VT_ELSE_SUBGRAPH_INDEX = 6
10148 };
10149 int32_t then_subgraph_index() const {
10150 return GetField<int32_t>(VT_THEN_SUBGRAPH_INDEX, 0);
10151 }
10152 int32_t else_subgraph_index() const {
10153 return GetField<int32_t>(VT_ELSE_SUBGRAPH_INDEX, 0);
10154 }
10155 bool Verify(flatbuffers::Verifier &verifier) const {
10156 return VerifyTableStart(verifier) &&
10157 VerifyField<int32_t>(verifier, VT_THEN_SUBGRAPH_INDEX, 4) &&
10158 VerifyField<int32_t>(verifier, VT_ELSE_SUBGRAPH_INDEX, 4) &&
10159 verifier.EndTable();
10160 }
10161 IfOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10162 void UnPackTo(IfOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10163 static flatbuffers::Offset<IfOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10164};
10165
10166struct IfOptionsBuilder {
10167 typedef IfOptions Table;
10169 flatbuffers::uoffset_t start_;
10171 fbb_.AddElement<int32_t>(IfOptions::VT_THEN_SUBGRAPH_INDEX, then_subgraph_index, 0);
10172 }
10174 fbb_.AddElement<int32_t>(IfOptions::VT_ELSE_SUBGRAPH_INDEX, else_subgraph_index, 0);
10175 }
10177 : fbb_(_fbb) {
10178 start_ = fbb_.StartTable();
10179 }
10180 flatbuffers::Offset<IfOptions> Finish() {
10181 const auto end = fbb_.EndTable(start_);
10182 auto o = flatbuffers::Offset<IfOptions>(end);
10183 return o;
10184 }
10185};
10186
10187inline flatbuffers::Offset<IfOptions> CreateIfOptions(
10189 int32_t then_subgraph_index = 0,
10190 int32_t else_subgraph_index = 0) {
10192 builder_.add_else_subgraph_index(else_subgraph_index);
10193 builder_.add_then_subgraph_index(then_subgraph_index);
10194 return builder_.Finish();
10195}
10196
10197flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10198
10199struct CallOnceOptionsT : public flatbuffers::NativeTable {
10200 typedef CallOnceOptions TableType;
10202};
10203
10204struct CallOnceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10207 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10208 VT_INIT_SUBGRAPH_INDEX = 4
10209 };
10210 int32_t init_subgraph_index() const {
10211 return GetField<int32_t>(VT_INIT_SUBGRAPH_INDEX, 0);
10212 }
10213 bool Verify(flatbuffers::Verifier &verifier) const {
10214 return VerifyTableStart(verifier) &&
10215 VerifyField<int32_t>(verifier, VT_INIT_SUBGRAPH_INDEX, 4) &&
10216 verifier.EndTable();
10217 }
10219 void UnPackTo(CallOnceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10220 static flatbuffers::Offset<CallOnceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10221};
10222
10224 typedef CallOnceOptions Table;
10226 flatbuffers::uoffset_t start_;
10228 fbb_.AddElement<int32_t>(CallOnceOptions::VT_INIT_SUBGRAPH_INDEX, init_subgraph_index, 0);
10229 }
10231 : fbb_(_fbb) {
10232 start_ = fbb_.StartTable();
10233 }
10234 flatbuffers::Offset<CallOnceOptions> Finish() {
10235 const auto end = fbb_.EndTable(start_);
10236 auto o = flatbuffers::Offset<CallOnceOptions>(end);
10237 return o;
10238 }
10239};
10240
10241inline flatbuffers::Offset<CallOnceOptions> CreateCallOnceOptions(
10243 int32_t init_subgraph_index = 0) {
10245 builder_.add_init_subgraph_index(init_subgraph_index);
10246 return builder_.Finish();
10247}
10248
10249flatbuffers::Offset<CallOnceOptions> CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10250
10251struct WhileOptionsT : public flatbuffers::NativeTable {
10252 typedef WhileOptions TableType;
10255};
10256
10257struct WhileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10260 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10262 VT_BODY_SUBGRAPH_INDEX = 6
10263 };
10264 int32_t cond_subgraph_index() const {
10265 return GetField<int32_t>(VT_COND_SUBGRAPH_INDEX, 0);
10266 }
10267 int32_t body_subgraph_index() const {
10268 return GetField<int32_t>(VT_BODY_SUBGRAPH_INDEX, 0);
10269 }
10270 bool Verify(flatbuffers::Verifier &verifier) const {
10271 return VerifyTableStart(verifier) &&
10272 VerifyField<int32_t>(verifier, VT_COND_SUBGRAPH_INDEX, 4) &&
10273 VerifyField<int32_t>(verifier, VT_BODY_SUBGRAPH_INDEX, 4) &&
10274 verifier.EndTable();
10275 }
10276 WhileOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10277 void UnPackTo(WhileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10278 static flatbuffers::Offset<WhileOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10279};
10280
10281struct WhileOptionsBuilder {
10282 typedef WhileOptions Table;
10284 flatbuffers::uoffset_t start_;
10286 fbb_.AddElement<int32_t>(WhileOptions::VT_COND_SUBGRAPH_INDEX, cond_subgraph_index, 0);
10287 }
10289 fbb_.AddElement<int32_t>(WhileOptions::VT_BODY_SUBGRAPH_INDEX, body_subgraph_index, 0);
10290 }
10292 : fbb_(_fbb) {
10293 start_ = fbb_.StartTable();
10294 }
10295 flatbuffers::Offset<WhileOptions> Finish() {
10296 const auto end = fbb_.EndTable(start_);
10297 auto o = flatbuffers::Offset<WhileOptions>(end);
10298 return o;
10299 }
10300};
10301
10302inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(
10304 int32_t cond_subgraph_index = 0,
10305 int32_t body_subgraph_index = 0) {
10307 builder_.add_body_subgraph_index(body_subgraph_index);
10308 builder_.add_cond_subgraph_index(cond_subgraph_index);
10309 return builder_.Finish();
10310}
10311
10312flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10313
10314struct NonMaxSuppressionV4OptionsT : public flatbuffers::NativeTable {
10315 typedef NonMaxSuppressionV4Options TableType;
10316};
10317
10318struct NonMaxSuppressionV4Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10321 bool Verify(flatbuffers::Verifier &verifier) const {
10322 return VerifyTableStart(verifier) &&
10323 verifier.EndTable();
10324 }
10326 void UnPackTo(NonMaxSuppressionV4OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10327 static flatbuffers::Offset<NonMaxSuppressionV4Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10328};
10329
10331 typedef NonMaxSuppressionV4Options Table;
10333 flatbuffers::uoffset_t start_;
10335 : fbb_(_fbb) {
10336 start_ = fbb_.StartTable();
10337 }
10338 flatbuffers::Offset<NonMaxSuppressionV4Options> Finish() {
10339 const auto end = fbb_.EndTable(start_);
10340 auto o = flatbuffers::Offset<NonMaxSuppressionV4Options>(end);
10341 return o;
10342 }
10343};
10344
10345inline flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(
10348 return builder_.Finish();
10349}
10350
10351flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10352
10353struct NonMaxSuppressionV5OptionsT : public flatbuffers::NativeTable {
10354 typedef NonMaxSuppressionV5Options TableType;
10355};
10356
10357struct NonMaxSuppressionV5Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10360 bool Verify(flatbuffers::Verifier &verifier) const {
10361 return VerifyTableStart(verifier) &&
10362 verifier.EndTable();
10363 }
10365 void UnPackTo(NonMaxSuppressionV5OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10366 static flatbuffers::Offset<NonMaxSuppressionV5Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10367};
10368
10370 typedef NonMaxSuppressionV5Options Table;
10372 flatbuffers::uoffset_t start_;
10374 : fbb_(_fbb) {
10375 start_ = fbb_.StartTable();
10376 }
10377 flatbuffers::Offset<NonMaxSuppressionV5Options> Finish() {
10378 const auto end = fbb_.EndTable(start_);
10379 auto o = flatbuffers::Offset<NonMaxSuppressionV5Options>(end);
10380 return o;
10381 }
10382};
10383
10384inline flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(
10387 return builder_.Finish();
10388}
10389
10390flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10391
10392struct ScatterNdOptionsT : public flatbuffers::NativeTable {
10393 typedef ScatterNdOptions TableType;
10394};
10395
10396struct ScatterNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10399 bool Verify(flatbuffers::Verifier &verifier) const {
10400 return VerifyTableStart(verifier) &&
10401 verifier.EndTable();
10402 }
10404 void UnPackTo(ScatterNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10405 static flatbuffers::Offset<ScatterNdOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10406};
10407
10409 typedef ScatterNdOptions Table;
10411 flatbuffers::uoffset_t start_;
10413 : fbb_(_fbb) {
10414 start_ = fbb_.StartTable();
10415 }
10416 flatbuffers::Offset<ScatterNdOptions> Finish() {
10417 const auto end = fbb_.EndTable(start_);
10418 auto o = flatbuffers::Offset<ScatterNdOptions>(end);
10419 return o;
10420 }
10421};
10422
10423inline flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(
10426 return builder_.Finish();
10427}
10428
10429flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10430
10431struct SelectV2OptionsT : public flatbuffers::NativeTable {
10432 typedef SelectV2Options TableType;
10433};
10434
10435struct SelectV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10438 bool Verify(flatbuffers::Verifier &verifier) const {
10439 return VerifyTableStart(verifier) &&
10440 verifier.EndTable();
10441 }
10443 void UnPackTo(SelectV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10444 static flatbuffers::Offset<SelectV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10445};
10446
10448 typedef SelectV2Options Table;
10450 flatbuffers::uoffset_t start_;
10452 : fbb_(_fbb) {
10453 start_ = fbb_.StartTable();
10454 }
10455 flatbuffers::Offset<SelectV2Options> Finish() {
10456 const auto end = fbb_.EndTable(start_);
10457 auto o = flatbuffers::Offset<SelectV2Options>(end);
10458 return o;
10459 }
10460};
10461
10462inline flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(
10465 return builder_.Finish();
10466}
10467
10468flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10469
10470struct DensifyOptionsT : public flatbuffers::NativeTable {
10471 typedef DensifyOptions TableType;
10472};
10473
10474struct DensifyOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10477 bool Verify(flatbuffers::Verifier &verifier) const {
10478 return VerifyTableStart(verifier) &&
10479 verifier.EndTable();
10480 }
10481 DensifyOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10482 void UnPackTo(DensifyOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10483 static flatbuffers::Offset<DensifyOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10484};
10485
10486struct DensifyOptionsBuilder {
10487 typedef DensifyOptions Table;
10489 flatbuffers::uoffset_t start_;
10491 : fbb_(_fbb) {
10492 start_ = fbb_.StartTable();
10493 }
10494 flatbuffers::Offset<DensifyOptions> Finish() {
10495 const auto end = fbb_.EndTable(start_);
10496 auto o = flatbuffers::Offset<DensifyOptions>(end);
10497 return o;
10498 }
10499};
10500
10501inline flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(
10504 return builder_.Finish();
10505}
10506
10507flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10508
10509struct SegmentSumOptionsT : public flatbuffers::NativeTable {
10510 typedef SegmentSumOptions TableType;
10511};
10512
10513struct SegmentSumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10516 bool Verify(flatbuffers::Verifier &verifier) const {
10517 return VerifyTableStart(verifier) &&
10518 verifier.EndTable();
10519 }
10521 void UnPackTo(SegmentSumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10522 static flatbuffers::Offset<SegmentSumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10523};
10524
10526 typedef SegmentSumOptions Table;
10528 flatbuffers::uoffset_t start_;
10530 : fbb_(_fbb) {
10531 start_ = fbb_.StartTable();
10532 }
10533 flatbuffers::Offset<SegmentSumOptions> Finish() {
10534 const auto end = fbb_.EndTable(start_);
10535 auto o = flatbuffers::Offset<SegmentSumOptions>(end);
10536 return o;
10537 }
10538};
10539
10540inline flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(
10543 return builder_.Finish();
10544}
10545
10546flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10547
10548struct BatchMatMulOptionsT : public flatbuffers::NativeTable {
10549 typedef BatchMatMulOptions TableType;
10550 bool adj_x = false;
10551 bool adj_y = false;
10552 bool asymmetric_quantize_inputs = false;
10553};
10554
10555struct BatchMatMulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10558 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10562 };
10563 bool adj_x() const {
10564 return GetField<uint8_t>(VT_ADJ_X, 0) != 0;
10565 }
10566 bool adj_y() const {
10567 return GetField<uint8_t>(VT_ADJ_Y, 0) != 0;
10568 }
10570 return GetField<uint8_t>(VT_ASYMMETRIC_QUANTIZE_INPUTS, 0) != 0;
10571 }
10572 bool Verify(flatbuffers::Verifier &verifier) const {
10573 return VerifyTableStart(verifier) &&
10574 VerifyField<uint8_t>(verifier, VT_ADJ_X, 1) &&
10575 VerifyField<uint8_t>(verifier, VT_ADJ_Y, 1) &&
10576 VerifyField<uint8_t>(verifier, VT_ASYMMETRIC_QUANTIZE_INPUTS, 1) &&
10577 verifier.EndTable();
10578 }
10580 void UnPackTo(BatchMatMulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10581 static flatbuffers::Offset<BatchMatMulOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10582};
10583
10585 typedef BatchMatMulOptions Table;
10587 flatbuffers::uoffset_t start_;
10588 void add_adj_x(bool adj_x) {
10589 fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJ_X, static_cast<uint8_t>(adj_x), 0);
10590 }
10591 void add_adj_y(bool adj_y) {
10592 fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ADJ_Y, static_cast<uint8_t>(adj_y), 0);
10593 }
10594 void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs) {
10595 fbb_.AddElement<uint8_t>(BatchMatMulOptions::VT_ASYMMETRIC_QUANTIZE_INPUTS, static_cast<uint8_t>(asymmetric_quantize_inputs), 0);
10596 }
10598 : fbb_(_fbb) {
10599 start_ = fbb_.StartTable();
10600 }
10601 flatbuffers::Offset<BatchMatMulOptions> Finish() {
10602 const auto end = fbb_.EndTable(start_);
10603 auto o = flatbuffers::Offset<BatchMatMulOptions>(end);
10604 return o;
10605 }
10606};
10607
10608inline flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(
10610 bool adj_x = false,
10611 bool adj_y = false,
10612 bool asymmetric_quantize_inputs = false) {
10614 builder_.add_asymmetric_quantize_inputs(asymmetric_quantize_inputs);
10615 builder_.add_adj_y(adj_y);
10616 builder_.add_adj_x(adj_x);
10617 return builder_.Finish();
10618}
10619
10620flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10621
10622struct CumsumOptionsT : public flatbuffers::NativeTable {
10623 typedef CumsumOptions TableType;
10624 bool exclusive = false;
10625 bool reverse = false;
10626};
10627
10628struct CumsumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10631 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10633 VT_REVERSE = 6
10634 };
10635 bool exclusive() const {
10636 return GetField<uint8_t>(VT_EXCLUSIVE, 0) != 0;
10637 }
10638 bool reverse() const {
10639 return GetField<uint8_t>(VT_REVERSE, 0) != 0;
10640 }
10641 bool Verify(flatbuffers::Verifier &verifier) const {
10642 return VerifyTableStart(verifier) &&
10643 VerifyField<uint8_t>(verifier, VT_EXCLUSIVE, 1) &&
10644 VerifyField<uint8_t>(verifier, VT_REVERSE, 1) &&
10645 verifier.EndTable();
10646 }
10647 CumsumOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10648 void UnPackTo(CumsumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10649 static flatbuffers::Offset<CumsumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10650};
10651
10652struct CumsumOptionsBuilder {
10653 typedef CumsumOptions Table;
10655 flatbuffers::uoffset_t start_;
10657 fbb_.AddElement<uint8_t>(CumsumOptions::VT_EXCLUSIVE, static_cast<uint8_t>(exclusive), 0);
10658 }
10660 fbb_.AddElement<uint8_t>(CumsumOptions::VT_REVERSE, static_cast<uint8_t>(reverse), 0);
10661 }
10663 : fbb_(_fbb) {
10664 start_ = fbb_.StartTable();
10665 }
10666 flatbuffers::Offset<CumsumOptions> Finish() {
10667 const auto end = fbb_.EndTable(start_);
10668 auto o = flatbuffers::Offset<CumsumOptions>(end);
10669 return o;
10670 }
10671};
10672
10673inline flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(
10675 bool exclusive = false,
10676 bool reverse = false) {
10678 builder_.add_reverse(reverse);
10679 builder_.add_exclusive(exclusive);
10680 return builder_.Finish();
10681}
10682
10683flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10684
10685struct BroadcastToOptionsT : public flatbuffers::NativeTable {
10686 typedef BroadcastToOptions TableType;
10687};
10688
10689struct BroadcastToOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10692 bool Verify(flatbuffers::Verifier &verifier) const {
10693 return VerifyTableStart(verifier) &&
10694 verifier.EndTable();
10695 }
10697 void UnPackTo(BroadcastToOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10698 static flatbuffers::Offset<BroadcastToOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10699};
10700
10702 typedef BroadcastToOptions Table;
10704 flatbuffers::uoffset_t start_;
10706 : fbb_(_fbb) {
10707 start_ = fbb_.StartTable();
10708 }
10709 flatbuffers::Offset<BroadcastToOptions> Finish() {
10710 const auto end = fbb_.EndTable(start_);
10711 auto o = flatbuffers::Offset<BroadcastToOptions>(end);
10712 return o;
10713 }
10714};
10715
10716inline flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(
10719 return builder_.Finish();
10720}
10721
10722flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10723
10724struct Rfft2dOptionsT : public flatbuffers::NativeTable {
10725 typedef Rfft2dOptions TableType;
10726};
10727
10728struct Rfft2dOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10731 bool Verify(flatbuffers::Verifier &verifier) const {
10732 return VerifyTableStart(verifier) &&
10733 verifier.EndTable();
10734 }
10735 Rfft2dOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10736 void UnPackTo(Rfft2dOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10737 static flatbuffers::Offset<Rfft2dOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10738};
10739
10740struct Rfft2dOptionsBuilder {
10741 typedef Rfft2dOptions Table;
10743 flatbuffers::uoffset_t start_;
10745 : fbb_(_fbb) {
10746 start_ = fbb_.StartTable();
10747 }
10748 flatbuffers::Offset<Rfft2dOptions> Finish() {
10749 const auto end = fbb_.EndTable(start_);
10750 auto o = flatbuffers::Offset<Rfft2dOptions>(end);
10751 return o;
10752 }
10753};
10754
10755inline flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(
10758 return builder_.Finish();
10759}
10760
10761flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10762
10763struct HashtableOptionsT : public flatbuffers::NativeTable {
10764 typedef HashtableOptions TableType;
10765 int32_t table_id = 0;
10768};
10769
10770struct HashtableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10773 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10776 VT_VALUE_DTYPE = 8
10777 };
10778 int32_t table_id() const {
10779 return GetField<int32_t>(VT_TABLE_ID, 0);
10780 }
10782 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_KEY_DTYPE, 0));
10783 }
10785 return static_cast<tflite::TensorType>(GetField<int8_t>(VT_VALUE_DTYPE, 0));
10786 }
10787 bool Verify(flatbuffers::Verifier &verifier) const {
10788 return VerifyTableStart(verifier) &&
10789 VerifyField<int32_t>(verifier, VT_TABLE_ID, 4) &&
10790 VerifyField<int8_t>(verifier, VT_KEY_DTYPE, 1) &&
10791 VerifyField<int8_t>(verifier, VT_VALUE_DTYPE, 1) &&
10792 verifier.EndTable();
10793 }
10795 void UnPackTo(HashtableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10796 static flatbuffers::Offset<HashtableOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10797};
10798
10800 typedef HashtableOptions Table;
10802 flatbuffers::uoffset_t start_;
10803 void add_table_id(int32_t table_id) {
10804 fbb_.AddElement<int32_t>(HashtableOptions::VT_TABLE_ID, table_id, 0);
10805 }
10807 fbb_.AddElement<int8_t>(HashtableOptions::VT_KEY_DTYPE, static_cast<int8_t>(key_dtype), 0);
10808 }
10810 fbb_.AddElement<int8_t>(HashtableOptions::VT_VALUE_DTYPE, static_cast<int8_t>(value_dtype), 0);
10811 }
10813 : fbb_(_fbb) {
10814 start_ = fbb_.StartTable();
10815 }
10816 flatbuffers::Offset<HashtableOptions> Finish() {
10817 const auto end = fbb_.EndTable(start_);
10818 auto o = flatbuffers::Offset<HashtableOptions>(end);
10819 return o;
10820 }
10821};
10822
10823inline flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(
10825 int32_t table_id = 0,
10829 builder_.add_table_id(table_id);
10830 builder_.add_value_dtype(value_dtype);
10831 builder_.add_key_dtype(key_dtype);
10832 return builder_.Finish();
10833}
10834
10835flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10836
10837struct HashtableFindOptionsT : public flatbuffers::NativeTable {
10838 typedef HashtableFindOptions TableType;
10839};
10840
10841struct HashtableFindOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10844 bool Verify(flatbuffers::Verifier &verifier) const {
10845 return VerifyTableStart(verifier) &&
10846 verifier.EndTable();
10847 }
10849 void UnPackTo(HashtableFindOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10850 static flatbuffers::Offset<HashtableFindOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10851};
10852
10854 typedef HashtableFindOptions Table;
10856 flatbuffers::uoffset_t start_;
10858 : fbb_(_fbb) {
10859 start_ = fbb_.StartTable();
10860 }
10861 flatbuffers::Offset<HashtableFindOptions> Finish() {
10862 const auto end = fbb_.EndTable(start_);
10863 auto o = flatbuffers::Offset<HashtableFindOptions>(end);
10864 return o;
10865 }
10866};
10867
10868inline flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(
10871 return builder_.Finish();
10872}
10873
10874flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10875
10876struct HashtableImportOptionsT : public flatbuffers::NativeTable {
10877 typedef HashtableImportOptions TableType;
10878};
10879
10880struct HashtableImportOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10883 bool Verify(flatbuffers::Verifier &verifier) const {
10884 return VerifyTableStart(verifier) &&
10885 verifier.EndTable();
10886 }
10888 void UnPackTo(HashtableImportOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10889 static flatbuffers::Offset<HashtableImportOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10890};
10891
10893 typedef HashtableImportOptions Table;
10895 flatbuffers::uoffset_t start_;
10897 : fbb_(_fbb) {
10898 start_ = fbb_.StartTable();
10899 }
10900 flatbuffers::Offset<HashtableImportOptions> Finish() {
10901 const auto end = fbb_.EndTable(start_);
10902 auto o = flatbuffers::Offset<HashtableImportOptions>(end);
10903 return o;
10904 }
10905};
10906
10907inline flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(
10910 return builder_.Finish();
10911}
10912
10913flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10914
10915struct HashtableSizeOptionsT : public flatbuffers::NativeTable {
10916 typedef HashtableSizeOptions TableType;
10917};
10918
10919struct HashtableSizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10922 bool Verify(flatbuffers::Verifier &verifier) const {
10923 return VerifyTableStart(verifier) &&
10924 verifier.EndTable();
10925 }
10927 void UnPackTo(HashtableSizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10928 static flatbuffers::Offset<HashtableSizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10929};
10930
10932 typedef HashtableSizeOptions Table;
10934 flatbuffers::uoffset_t start_;
10936 : fbb_(_fbb) {
10937 start_ = fbb_.StartTable();
10938 }
10939 flatbuffers::Offset<HashtableSizeOptions> Finish() {
10940 const auto end = fbb_.EndTable(start_);
10941 auto o = flatbuffers::Offset<HashtableSizeOptions>(end);
10942 return o;
10943 }
10944};
10945
10946inline flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(
10949 return builder_.Finish();
10950}
10951
10952flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10953
10954struct VarHandleOptionsT : public flatbuffers::NativeTable {
10955 typedef VarHandleOptions TableType;
10956 std::string container{};
10957 std::string shared_name{};
10958};
10959
10960struct VarHandleOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
10963 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
10965 VT_SHARED_NAME = 6
10966 };
10968 return GetPointer<const flatbuffers::String *>(VT_CONTAINER);
10969 }
10971 return GetPointer<const flatbuffers::String *>(VT_SHARED_NAME);
10972 }
10973 bool Verify(flatbuffers::Verifier &verifier) const {
10974 return VerifyTableStart(verifier) &&
10975 VerifyOffset(verifier, VT_CONTAINER) &&
10976 verifier.VerifyString(container()) &&
10977 VerifyOffset(verifier, VT_SHARED_NAME) &&
10978 verifier.VerifyString(shared_name()) &&
10979 verifier.EndTable();
10980 }
10982 void UnPackTo(VarHandleOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
10983 static flatbuffers::Offset<VarHandleOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
10984};
10985
10987 typedef VarHandleOptions Table;
10989 flatbuffers::uoffset_t start_;
10990 void add_container(flatbuffers::Offset<flatbuffers::String> container) {
10991 fbb_.AddOffset(VarHandleOptions::VT_CONTAINER, container);
10992 }
10993 void add_shared_name(flatbuffers::Offset<flatbuffers::String> shared_name) {
10994 fbb_.AddOffset(VarHandleOptions::VT_SHARED_NAME, shared_name);
10995 }
10997 : fbb_(_fbb) {
10998 start_ = fbb_.StartTable();
10999 }
11000 flatbuffers::Offset<VarHandleOptions> Finish() {
11001 const auto end = fbb_.EndTable(start_);
11002 auto o = flatbuffers::Offset<VarHandleOptions>(end);
11003 return o;
11004 }
11005};
11006
11007inline flatbuffers::Offset<VarHandleOptions> CreateVarHandleOptions(
11009 flatbuffers::Offset<flatbuffers::String> container = 0,
11010 flatbuffers::Offset<flatbuffers::String> shared_name = 0) {
11012 builder_.add_shared_name(shared_name);
11013 builder_.add_container(container);
11014 return builder_.Finish();
11015}
11016
11017inline flatbuffers::Offset<VarHandleOptions> CreateVarHandleOptionsDirect(
11019 const char *container = nullptr,
11020 const char *shared_name = nullptr) {
11021 auto container__ = container ? _fbb.CreateString(container) : 0;
11022 auto shared_name__ = shared_name ? _fbb.CreateString(shared_name) : 0;
11024 _fbb,
11025 container__,
11026 shared_name__);
11027}
11028
11029flatbuffers::Offset<VarHandleOptions> CreateVarHandleOptions(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11030
11031struct ReadVariableOptionsT : public flatbuffers::NativeTable {
11032 typedef ReadVariableOptions TableType;
11033};
11034
11035struct ReadVariableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11038 bool Verify(flatbuffers::Verifier &verifier) const {
11039 return VerifyTableStart(verifier) &&
11040 verifier.EndTable();
11041 }
11043 void UnPackTo(ReadVariableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11044 static flatbuffers::Offset<ReadVariableOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11045};
11046
11048 typedef ReadVariableOptions Table;
11050 flatbuffers::uoffset_t start_;
11052 : fbb_(_fbb) {
11053 start_ = fbb_.StartTable();
11054 }
11055 flatbuffers::Offset<ReadVariableOptions> Finish() {
11056 const auto end = fbb_.EndTable(start_);
11057 auto o = flatbuffers::Offset<ReadVariableOptions>(end);
11058 return o;
11059 }
11060};
11061
11062inline flatbuffers::Offset<ReadVariableOptions> CreateReadVariableOptions(
11065 return builder_.Finish();
11066}
11067
11068flatbuffers::Offset<ReadVariableOptions> CreateReadVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11069
11070struct AssignVariableOptionsT : public flatbuffers::NativeTable {
11071 typedef AssignVariableOptions TableType;
11072};
11073
11074struct AssignVariableOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11077 bool Verify(flatbuffers::Verifier &verifier) const {
11078 return VerifyTableStart(verifier) &&
11079 verifier.EndTable();
11080 }
11082 void UnPackTo(AssignVariableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11083 static flatbuffers::Offset<AssignVariableOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11084};
11085
11087 typedef AssignVariableOptions Table;
11089 flatbuffers::uoffset_t start_;
11091 : fbb_(_fbb) {
11092 start_ = fbb_.StartTable();
11093 }
11094 flatbuffers::Offset<AssignVariableOptions> Finish() {
11095 const auto end = fbb_.EndTable(start_);
11096 auto o = flatbuffers::Offset<AssignVariableOptions>(end);
11097 return o;
11098 }
11099};
11100
11101inline flatbuffers::Offset<AssignVariableOptions> CreateAssignVariableOptions(
11104 return builder_.Finish();
11105}
11106
11107flatbuffers::Offset<AssignVariableOptions> CreateAssignVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11108
11109struct RandomOptionsT : public flatbuffers::NativeTable {
11110 typedef RandomOptions TableType;
11111 int64_t seed = 0;
11112 int64_t seed2 = 0;
11113};
11114
11115struct RandomOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11118 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11120 VT_SEED2 = 6
11121 };
11122 int64_t seed() const {
11123 return GetField<int64_t>(VT_SEED, 0);
11124 }
11125 int64_t seed2() const {
11126 return GetField<int64_t>(VT_SEED2, 0);
11127 }
11128 bool Verify(flatbuffers::Verifier &verifier) const {
11129 return VerifyTableStart(verifier) &&
11130 VerifyField<int64_t>(verifier, VT_SEED, 8) &&
11131 VerifyField<int64_t>(verifier, VT_SEED2, 8) &&
11132 verifier.EndTable();
11133 }
11134 RandomOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11135 void UnPackTo(RandomOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11136 static flatbuffers::Offset<RandomOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11137};
11138
11139struct RandomOptionsBuilder {
11140 typedef RandomOptions Table;
11142 flatbuffers::uoffset_t start_;
11143 void add_seed(int64_t seed) {
11144 fbb_.AddElement<int64_t>(RandomOptions::VT_SEED, seed, 0);
11145 }
11146 void add_seed2(int64_t seed2) {
11147 fbb_.AddElement<int64_t>(RandomOptions::VT_SEED2, seed2, 0);
11148 }
11150 : fbb_(_fbb) {
11151 start_ = fbb_.StartTable();
11152 }
11153 flatbuffers::Offset<RandomOptions> Finish() {
11154 const auto end = fbb_.EndTable(start_);
11155 auto o = flatbuffers::Offset<RandomOptions>(end);
11156 return o;
11157 }
11158};
11159
11160inline flatbuffers::Offset<RandomOptions> CreateRandomOptions(
11162 int64_t seed = 0,
11163 int64_t seed2 = 0) {
11165 builder_.add_seed2(seed2);
11166 builder_.add_seed(seed);
11167 return builder_.Finish();
11168}
11169
11170flatbuffers::Offset<RandomOptions> CreateRandomOptions(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11171
11172struct BucketizeOptionsT : public flatbuffers::NativeTable {
11173 typedef BucketizeOptions TableType;
11174 std::vector<float> boundaries{};
11175};
11176
11177struct BucketizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11180 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11181 VT_BOUNDARIES = 4
11182 };
11184 return GetPointer<const flatbuffers::Vector<float> *>(VT_BOUNDARIES);
11185 }
11186 bool Verify(flatbuffers::Verifier &verifier) const {
11187 return VerifyTableStart(verifier) &&
11188 VerifyOffset(verifier, VT_BOUNDARIES) &&
11189 verifier.VerifyVector(boundaries()) &&
11190 verifier.EndTable();
11191 }
11193 void UnPackTo(BucketizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11194 static flatbuffers::Offset<BucketizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11195};
11196
11198 typedef BucketizeOptions Table;
11200 flatbuffers::uoffset_t start_;
11201 void add_boundaries(flatbuffers::Offset<flatbuffers::Vector<float>> boundaries) {
11202 fbb_.AddOffset(BucketizeOptions::VT_BOUNDARIES, boundaries);
11203 }
11205 : fbb_(_fbb) {
11206 start_ = fbb_.StartTable();
11207 }
11208 flatbuffers::Offset<BucketizeOptions> Finish() {
11209 const auto end = fbb_.EndTable(start_);
11210 auto o = flatbuffers::Offset<BucketizeOptions>(end);
11211 return o;
11212 }
11213};
11214
11215inline flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptions(
11217 flatbuffers::Offset<flatbuffers::Vector<float>> boundaries = 0) {
11219 builder_.add_boundaries(boundaries);
11220 return builder_.Finish();
11221}
11222
11223inline flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptionsDirect(
11225 const std::vector<float> *boundaries = nullptr) {
11226 auto boundaries__ = boundaries ? _fbb.CreateVector<float>(*boundaries) : 0;
11228 _fbb,
11229 boundaries__);
11230}
11231
11232flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11233
11234struct GeluOptionsT : public flatbuffers::NativeTable {
11235 typedef GeluOptions TableType;
11236 bool approximate = false;
11237};
11238
11239struct GeluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11242 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11243 VT_APPROXIMATE = 4
11244 };
11245 bool approximate() const {
11246 return GetField<uint8_t>(VT_APPROXIMATE, 0) != 0;
11247 }
11248 bool Verify(flatbuffers::Verifier &verifier) const {
11249 return VerifyTableStart(verifier) &&
11250 VerifyField<uint8_t>(verifier, VT_APPROXIMATE, 1) &&
11251 verifier.EndTable();
11252 }
11253 GeluOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11254 void UnPackTo(GeluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11255 static flatbuffers::Offset<GeluOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11256};
11257
11258struct GeluOptionsBuilder {
11259 typedef GeluOptions Table;
11261 flatbuffers::uoffset_t start_;
11262 void add_approximate(bool approximate) {
11263 fbb_.AddElement<uint8_t>(GeluOptions::VT_APPROXIMATE, static_cast<uint8_t>(approximate), 0);
11264 }
11266 : fbb_(_fbb) {
11267 start_ = fbb_.StartTable();
11268 }
11269 flatbuffers::Offset<GeluOptions> Finish() {
11270 const auto end = fbb_.EndTable(start_);
11271 auto o = flatbuffers::Offset<GeluOptions>(end);
11272 return o;
11273 }
11274};
11275
11276inline flatbuffers::Offset<GeluOptions> CreateGeluOptions(
11278 bool approximate = false) {
11280 builder_.add_approximate(approximate);
11281 return builder_.Finish();
11282}
11283
11284flatbuffers::Offset<GeluOptions> CreateGeluOptions(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11285
11286struct DynamicUpdateSliceOptionsT : public flatbuffers::NativeTable {
11287 typedef DynamicUpdateSliceOptions TableType;
11288};
11289
11290struct DynamicUpdateSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11293 bool Verify(flatbuffers::Verifier &verifier) const {
11294 return VerifyTableStart(verifier) &&
11295 verifier.EndTable();
11296 }
11298 void UnPackTo(DynamicUpdateSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11299 static flatbuffers::Offset<DynamicUpdateSliceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11300};
11301
11303 typedef DynamicUpdateSliceOptions Table;
11305 flatbuffers::uoffset_t start_;
11307 : fbb_(_fbb) {
11308 start_ = fbb_.StartTable();
11309 }
11310 flatbuffers::Offset<DynamicUpdateSliceOptions> Finish() {
11311 const auto end = fbb_.EndTable(start_);
11312 auto o = flatbuffers::Offset<DynamicUpdateSliceOptions>(end);
11313 return o;
11314 }
11315};
11316
11317inline flatbuffers::Offset<DynamicUpdateSliceOptions> CreateDynamicUpdateSliceOptions(
11320 return builder_.Finish();
11321}
11322
11323flatbuffers::Offset<DynamicUpdateSliceOptions> CreateDynamicUpdateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11324
11325struct UnsortedSegmentProdOptionsT : public flatbuffers::NativeTable {
11326 typedef UnsortedSegmentProdOptions TableType;
11327};
11328
11329struct UnsortedSegmentProdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11332 bool Verify(flatbuffers::Verifier &verifier) const {
11333 return VerifyTableStart(verifier) &&
11334 verifier.EndTable();
11335 }
11337 void UnPackTo(UnsortedSegmentProdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11338 static flatbuffers::Offset<UnsortedSegmentProdOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11339};
11340
11342 typedef UnsortedSegmentProdOptions Table;
11344 flatbuffers::uoffset_t start_;
11346 : fbb_(_fbb) {
11347 start_ = fbb_.StartTable();
11348 }
11349 flatbuffers::Offset<UnsortedSegmentProdOptions> Finish() {
11350 const auto end = fbb_.EndTable(start_);
11351 auto o = flatbuffers::Offset<UnsortedSegmentProdOptions>(end);
11352 return o;
11353 }
11354};
11355
11356inline flatbuffers::Offset<UnsortedSegmentProdOptions> CreateUnsortedSegmentProdOptions(
11359 return builder_.Finish();
11360}
11361
11362flatbuffers::Offset<UnsortedSegmentProdOptions> CreateUnsortedSegmentProdOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11363
11364struct UnsortedSegmentMaxOptionsT : public flatbuffers::NativeTable {
11365 typedef UnsortedSegmentMaxOptions TableType;
11366};
11367
11368struct UnsortedSegmentMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11371 bool Verify(flatbuffers::Verifier &verifier) const {
11372 return VerifyTableStart(verifier) &&
11373 verifier.EndTable();
11374 }
11376 void UnPackTo(UnsortedSegmentMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11377 static flatbuffers::Offset<UnsortedSegmentMaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11378};
11379
11381 typedef UnsortedSegmentMaxOptions Table;
11383 flatbuffers::uoffset_t start_;
11385 : fbb_(_fbb) {
11386 start_ = fbb_.StartTable();
11387 }
11388 flatbuffers::Offset<UnsortedSegmentMaxOptions> Finish() {
11389 const auto end = fbb_.EndTable(start_);
11390 auto o = flatbuffers::Offset<UnsortedSegmentMaxOptions>(end);
11391 return o;
11392 }
11393};
11394
11395inline flatbuffers::Offset<UnsortedSegmentMaxOptions> CreateUnsortedSegmentMaxOptions(
11398 return builder_.Finish();
11399}
11400
11401flatbuffers::Offset<UnsortedSegmentMaxOptions> CreateUnsortedSegmentMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11402
11403struct UnsortedSegmentSumOptionsT : public flatbuffers::NativeTable {
11404 typedef UnsortedSegmentSumOptions TableType;
11405};
11406
11407struct UnsortedSegmentSumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11410 bool Verify(flatbuffers::Verifier &verifier) const {
11411 return VerifyTableStart(verifier) &&
11412 verifier.EndTable();
11413 }
11415 void UnPackTo(UnsortedSegmentSumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11416 static flatbuffers::Offset<UnsortedSegmentSumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11417};
11418
11420 typedef UnsortedSegmentSumOptions Table;
11422 flatbuffers::uoffset_t start_;
11424 : fbb_(_fbb) {
11425 start_ = fbb_.StartTable();
11426 }
11427 flatbuffers::Offset<UnsortedSegmentSumOptions> Finish() {
11428 const auto end = fbb_.EndTable(start_);
11429 auto o = flatbuffers::Offset<UnsortedSegmentSumOptions>(end);
11430 return o;
11431 }
11432};
11433
11434inline flatbuffers::Offset<UnsortedSegmentSumOptions> CreateUnsortedSegmentSumOptions(
11437 return builder_.Finish();
11438}
11439
11440flatbuffers::Offset<UnsortedSegmentSumOptions> CreateUnsortedSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11441
11442struct ATan2OptionsT : public flatbuffers::NativeTable {
11443 typedef ATan2Options TableType;
11444};
11445
11446struct ATan2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11449 bool Verify(flatbuffers::Verifier &verifier) const {
11450 return VerifyTableStart(verifier) &&
11451 verifier.EndTable();
11452 }
11453 ATan2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11454 void UnPackTo(ATan2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11455 static flatbuffers::Offset<ATan2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11456};
11457
11458struct ATan2OptionsBuilder {
11459 typedef ATan2Options Table;
11461 flatbuffers::uoffset_t start_;
11463 : fbb_(_fbb) {
11464 start_ = fbb_.StartTable();
11465 }
11466 flatbuffers::Offset<ATan2Options> Finish() {
11467 const auto end = fbb_.EndTable(start_);
11468 auto o = flatbuffers::Offset<ATan2Options>(end);
11469 return o;
11470 }
11471};
11472
11473inline flatbuffers::Offset<ATan2Options> CreateATan2Options(
11476 return builder_.Finish();
11477}
11478
11479flatbuffers::Offset<ATan2Options> CreateATan2Options(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11480
11481struct UnsortedSegmentMinOptionsT : public flatbuffers::NativeTable {
11482 typedef UnsortedSegmentMinOptions TableType;
11483};
11484
11485struct UnsortedSegmentMinOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11488 bool Verify(flatbuffers::Verifier &verifier) const {
11489 return VerifyTableStart(verifier) &&
11490 verifier.EndTable();
11491 }
11493 void UnPackTo(UnsortedSegmentMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11494 static flatbuffers::Offset<UnsortedSegmentMinOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11495};
11496
11498 typedef UnsortedSegmentMinOptions Table;
11500 flatbuffers::uoffset_t start_;
11502 : fbb_(_fbb) {
11503 start_ = fbb_.StartTable();
11504 }
11505 flatbuffers::Offset<UnsortedSegmentMinOptions> Finish() {
11506 const auto end = fbb_.EndTable(start_);
11507 auto o = flatbuffers::Offset<UnsortedSegmentMinOptions>(end);
11508 return o;
11509 }
11510};
11511
11512inline flatbuffers::Offset<UnsortedSegmentMinOptions> CreateUnsortedSegmentMinOptions(
11515 return builder_.Finish();
11516}
11517
11518flatbuffers::Offset<UnsortedSegmentMinOptions> CreateUnsortedSegmentMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11519
11520struct SignOptionsT : public flatbuffers::NativeTable {
11521 typedef SignOptions TableType;
11522};
11523
11524struct SignOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11527 bool Verify(flatbuffers::Verifier &verifier) const {
11528 return VerifyTableStart(verifier) &&
11529 verifier.EndTable();
11530 }
11531 SignOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11532 void UnPackTo(SignOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11533 static flatbuffers::Offset<SignOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11534};
11535
11536struct SignOptionsBuilder {
11537 typedef SignOptions Table;
11539 flatbuffers::uoffset_t start_;
11541 : fbb_(_fbb) {
11542 start_ = fbb_.StartTable();
11543 }
11544 flatbuffers::Offset<SignOptions> Finish() {
11545 const auto end = fbb_.EndTable(start_);
11546 auto o = flatbuffers::Offset<SignOptions>(end);
11547 return o;
11548 }
11549};
11550
11551inline flatbuffers::Offset<SignOptions> CreateSignOptions(
11554 return builder_.Finish();
11555}
11556
11557flatbuffers::Offset<SignOptions> CreateSignOptions(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11558
11559struct OperatorCodeT : public flatbuffers::NativeTable {
11560 typedef OperatorCode TableType;
11561 int8_t deprecated_builtin_code = 0;
11562 std::string custom_code{};
11563 int32_t version = 1;
11565};
11566
11567struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11570 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11574 VT_BUILTIN_CODE = 10
11575 };
11577 return GetField<int8_t>(VT_DEPRECATED_BUILTIN_CODE, 0);
11578 }
11580 return GetPointer<const flatbuffers::String *>(VT_CUSTOM_CODE);
11581 }
11582 int32_t version() const {
11583 return GetField<int32_t>(VT_VERSION, 1);
11584 }
11586 return static_cast<tflite::BuiltinOperator>(GetField<int32_t>(VT_BUILTIN_CODE, 0));
11587 }
11588 bool Verify(flatbuffers::Verifier &verifier) const {
11589 return VerifyTableStart(verifier) &&
11590 VerifyField<int8_t>(verifier, VT_DEPRECATED_BUILTIN_CODE, 1) &&
11591 VerifyOffset(verifier, VT_CUSTOM_CODE) &&
11592 verifier.VerifyString(custom_code()) &&
11593 VerifyField<int32_t>(verifier, VT_VERSION, 4) &&
11594 VerifyField<int32_t>(verifier, VT_BUILTIN_CODE, 4) &&
11595 verifier.EndTable();
11596 }
11597 OperatorCodeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11598 void UnPackTo(OperatorCodeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
11599 static flatbuffers::Offset<OperatorCode> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11600};
11601
11602struct OperatorCodeBuilder {
11603 typedef OperatorCode Table;
11605 flatbuffers::uoffset_t start_;
11606 void add_deprecated_builtin_code(int8_t deprecated_builtin_code) {
11607 fbb_.AddElement<int8_t>(OperatorCode::VT_DEPRECATED_BUILTIN_CODE, deprecated_builtin_code, 0);
11608 }
11609 void add_custom_code(flatbuffers::Offset<flatbuffers::String> custom_code) {
11610 fbb_.AddOffset(OperatorCode::VT_CUSTOM_CODE, custom_code);
11611 }
11612 void add_version(int32_t version) {
11613 fbb_.AddElement<int32_t>(OperatorCode::VT_VERSION, version, 1);
11614 }
11616 fbb_.AddElement<int32_t>(OperatorCode::VT_BUILTIN_CODE, static_cast<int32_t>(builtin_code), 0);
11617 }
11619 : fbb_(_fbb) {
11620 start_ = fbb_.StartTable();
11621 }
11622 flatbuffers::Offset<OperatorCode> Finish() {
11623 const auto end = fbb_.EndTable(start_);
11624 auto o = flatbuffers::Offset<OperatorCode>(end);
11625 return o;
11626 }
11627};
11628
11629inline flatbuffers::Offset<OperatorCode> CreateOperatorCode(
11631 int8_t deprecated_builtin_code = 0,
11632 flatbuffers::Offset<flatbuffers::String> custom_code = 0,
11633 int32_t version = 1,
11636 builder_.add_builtin_code(builtin_code);
11637 builder_.add_version(version);
11638 builder_.add_custom_code(custom_code);
11639 builder_.add_deprecated_builtin_code(deprecated_builtin_code);
11640 return builder_.Finish();
11641}
11642
11643inline flatbuffers::Offset<OperatorCode> CreateOperatorCodeDirect(
11645 int8_t deprecated_builtin_code = 0,
11646 const char *custom_code = nullptr,
11647 int32_t version = 1,
11649 auto custom_code__ = custom_code ? _fbb.CreateString(custom_code) : 0;
11651 _fbb,
11652 deprecated_builtin_code,
11653 custom_code__,
11654 version,
11655 builtin_code);
11656}
11657
11658flatbuffers::Offset<OperatorCode> CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
11659
11660struct OperatorT : public flatbuffers::NativeTable {
11661 typedef Operator TableType;
11662 uint32_t opcode_index = 0;
11663 std::vector<int32_t> inputs{};
11664 std::vector<int32_t> outputs{};
11666 std::vector<uint8_t> custom_options{};
11668 std::vector<bool> mutating_variable_inputs{};
11669 std::vector<int32_t> intermediates{};
11670};
11671
11672struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
11675 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
11684 VT_INTERMEDIATES = 20
11685 };
11686 uint32_t opcode_index() const {
11687 return GetField<uint32_t>(VT_OPCODE_INDEX, 0);
11688 }
11690 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
11691 }
11693 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
11694 }
11696 return static_cast<tflite::BuiltinOptions>(GetField<uint8_t>(VT_BUILTIN_OPTIONS_TYPE, 0));
11697 }
11698 const void *builtin_options() const {
11699 return GetPointer<const void *>(VT_BUILTIN_OPTIONS);
11700 }
11701 template<typename T> const T *builtin_options_as() const;
11702 const tflite::Conv2DOptions *builtin_options_as_Conv2DOptions() const {
11703 return builtin_options_type() == tflite::BuiltinOptions_Conv2DOptions ? static_cast<const tflite::Conv2DOptions *>(builtin_options()) : nullptr;
11704 }
11705 const tflite::DepthwiseConv2DOptions *builtin_options_as_DepthwiseConv2DOptions() const {
11706 return builtin_options_type() == tflite::BuiltinOptions_DepthwiseConv2DOptions ? static_cast<const tflite::DepthwiseConv2DOptions *>(builtin_options()) : nullptr;
11707 }
11708 const tflite::ConcatEmbeddingsOptions *builtin_options_as_ConcatEmbeddingsOptions() const {
11709 return builtin_options_type() == tflite::BuiltinOptions_ConcatEmbeddingsOptions ? static_cast<const tflite::ConcatEmbeddingsOptions *>(builtin_options()) : nullptr;
11710 }
11711 const tflite::LSHProjectionOptions *builtin_options_as_LSHProjectionOptions() const {
11712 return builtin_options_type() == tflite::BuiltinOptions_LSHProjectionOptions ? static_cast<const tflite::LSHProjectionOptions *>(builtin_options()) : nullptr;
11713 }
11714 const tflite::Pool2DOptions *builtin_options_as_Pool2DOptions() const {
11715 return builtin_options_type() == tflite::BuiltinOptions_Pool2DOptions ? static_cast<const tflite::Pool2DOptions *>(builtin_options()) : nullptr;
11716 }
11717 const tflite::SVDFOptions *builtin_options_as_SVDFOptions() const {
11718 return builtin_options_type() == tflite::BuiltinOptions_SVDFOptions ? static_cast<const tflite::SVDFOptions *>(builtin_options()) : nullptr;
11719 }
11720 const tflite::RNNOptions *builtin_options_as_RNNOptions() const {
11721 return builtin_options_type() == tflite::BuiltinOptions_RNNOptions ? static_cast<const tflite::RNNOptions *>(builtin_options()) : nullptr;
11722 }
11723 const tflite::FullyConnectedOptions *builtin_options_as_FullyConnectedOptions() const {
11724 return builtin_options_type() == tflite::BuiltinOptions_FullyConnectedOptions ? static_cast<const tflite::FullyConnectedOptions *>(builtin_options()) : nullptr;
11725 }
11726 const tflite::SoftmaxOptions *builtin_options_as_SoftmaxOptions() const {
11727 return builtin_options_type() == tflite::BuiltinOptions_SoftmaxOptions ? static_cast<const tflite::SoftmaxOptions *>(builtin_options()) : nullptr;
11728 }
11729 const tflite::ConcatenationOptions *builtin_options_as_ConcatenationOptions() const {
11730 return builtin_options_type() == tflite::BuiltinOptions_ConcatenationOptions ? static_cast<const tflite::ConcatenationOptions *>(builtin_options()) : nullptr;
11731 }
11732 const tflite::AddOptions *builtin_options_as_AddOptions() const {
11733 return builtin_options_type() == tflite::BuiltinOptions_AddOptions ? static_cast<const tflite::AddOptions *>(builtin_options()) : nullptr;
11734 }
11735 const tflite::L2NormOptions *builtin_options_as_L2NormOptions() const {
11736 return builtin_options_type() == tflite::BuiltinOptions_L2NormOptions ? static_cast<const tflite::L2NormOptions *>(builtin_options()) : nullptr;
11737 }
11738 const tflite::LocalResponseNormalizationOptions *builtin_options_as_LocalResponseNormalizationOptions() const {
11739 return builtin_options_type() == tflite::BuiltinOptions_LocalResponseNormalizationOptions ? static_cast<const tflite::LocalResponseNormalizationOptions *>(builtin_options()) : nullptr;
11740 }
11741 const tflite::LSTMOptions *builtin_options_as_LSTMOptions() const {
11742 return builtin_options_type() == tflite::BuiltinOptions_LSTMOptions ? static_cast<const tflite::LSTMOptions *>(builtin_options()) : nullptr;
11743 }
11744 const tflite::ResizeBilinearOptions *builtin_options_as_ResizeBilinearOptions() const {
11745 return builtin_options_type() == tflite::BuiltinOptions_ResizeBilinearOptions ? static_cast<const tflite::ResizeBilinearOptions *>(builtin_options()) : nullptr;
11746 }
11747 const tflite::CallOptions *builtin_options_as_CallOptions() const {
11748 return builtin_options_type() == tflite::BuiltinOptions_CallOptions ? static_cast<const tflite::CallOptions *>(builtin_options()) : nullptr;
11749 }
11750 const tflite::ReshapeOptions *builtin_options_as_ReshapeOptions() const {
11751 return builtin_options_type() == tflite::BuiltinOptions_ReshapeOptions ? static_cast<const tflite::ReshapeOptions *>(builtin_options()) : nullptr;
11752 }
11753 const tflite::SkipGramOptions *builtin_options_as_SkipGramOptions() const {
11754 return builtin_options_type() == tflite::BuiltinOptions_SkipGramOptions ? static_cast<const tflite::SkipGramOptions *>(builtin_options()) : nullptr;
11755 }
11756 const tflite::SpaceToDepthOptions *builtin_options_as_SpaceToDepthOptions() const {
11757 return builtin_options_type() == tflite::BuiltinOptions_SpaceToDepthOptions ? static_cast<const tflite::SpaceToDepthOptions *>(builtin_options()) : nullptr;
11758 }
11759 const tflite::EmbeddingLookupSparseOptions *builtin_options_as_EmbeddingLookupSparseOptions() const {
11760 return builtin_options_type() == tflite::BuiltinOptions_EmbeddingLookupSparseOptions ? static_cast<const tflite::EmbeddingLookupSparseOptions *>(builtin_options()) : nullptr;
11761 }
11762 const tflite::MulOptions *builtin_options_as_MulOptions() const {
11763 return builtin_options_type() == tflite::BuiltinOptions_MulOptions ? static_cast<const tflite::MulOptions *>(builtin_options()) : nullptr;
11764 }
11765 const tflite::PadOptions *builtin_options_as_PadOptions() const {
11766 return builtin_options_type() == tflite::BuiltinOptions_PadOptions ? static_cast<const tflite::PadOptions *>(builtin_options()) : nullptr;
11767 }
11768 const tflite::GatherOptions *builtin_options_as_GatherOptions() const {
11769 return builtin_options_type() == tflite::BuiltinOptions_GatherOptions ? static_cast<const tflite::GatherOptions *>(builtin_options()) : nullptr;
11770 }
11771 const tflite::BatchToSpaceNDOptions *builtin_options_as_BatchToSpaceNDOptions() const {
11772 return builtin_options_type() == tflite::BuiltinOptions_BatchToSpaceNDOptions ? static_cast<const tflite::BatchToSpaceNDOptions *>(builtin_options()) : nullptr;
11773 }
11774 const tflite::SpaceToBatchNDOptions *builtin_options_as_SpaceToBatchNDOptions() const {
11775 return builtin_options_type() == tflite::BuiltinOptions_SpaceToBatchNDOptions ? static_cast<const tflite::SpaceToBatchNDOptions *>(builtin_options()) : nullptr;
11776 }
11777 const tflite::TransposeOptions *builtin_options_as_TransposeOptions() const {
11778 return builtin_options_type() == tflite::BuiltinOptions_TransposeOptions ? static_cast<const tflite::TransposeOptions *>(builtin_options()) : nullptr;
11779 }
11780 const tflite::ReducerOptions *builtin_options_as_ReducerOptions() const {
11781 return builtin_options_type() == tflite::BuiltinOptions_ReducerOptions ? static_cast<const tflite::ReducerOptions *>(builtin_options()) : nullptr;
11782 }
11783 const tflite::SubOptions *builtin_options_as_SubOptions() const {
11784 return builtin_options_type() == tflite::BuiltinOptions_SubOptions ? static_cast<const tflite::SubOptions *>(builtin_options()) : nullptr;
11785 }
11786 const tflite::DivOptions *builtin_options_as_DivOptions() const {
11787 return builtin_options_type() == tflite::BuiltinOptions_DivOptions ? static_cast<const tflite::DivOptions *>(builtin_options()) : nullptr;
11788 }
11789 const tflite::SqueezeOptions *builtin_options_as_SqueezeOptions() const {
11790 return builtin_options_type() == tflite::BuiltinOptions_SqueezeOptions ? static_cast<const tflite::SqueezeOptions *>(builtin_options()) : nullptr;
11791 }
11792 const tflite::SequenceRNNOptions *builtin_options_as_SequenceRNNOptions() const {
11793 return builtin_options_type() == tflite::BuiltinOptions_SequenceRNNOptions ? static_cast<const tflite::SequenceRNNOptions *>(builtin_options()) : nullptr;
11794 }
11795 const tflite::StridedSliceOptions *builtin_options_as_StridedSliceOptions() const {
11796 return builtin_options_type() == tflite::BuiltinOptions_StridedSliceOptions ? static_cast<const tflite::StridedSliceOptions *>(builtin_options()) : nullptr;
11797 }
11798 const tflite::ExpOptions *builtin_options_as_ExpOptions() const {
11799 return builtin_options_type() == tflite::BuiltinOptions_ExpOptions ? static_cast<const tflite::ExpOptions *>(builtin_options()) : nullptr;
11800 }
11801 const tflite::TopKV2Options *builtin_options_as_TopKV2Options() const {
11802 return builtin_options_type() == tflite::BuiltinOptions_TopKV2Options ? static_cast<const tflite::TopKV2Options *>(builtin_options()) : nullptr;
11803 }
11804 const tflite::SplitOptions *builtin_options_as_SplitOptions() const {
11805 return builtin_options_type() == tflite::BuiltinOptions_SplitOptions ? static_cast<const tflite::SplitOptions *>(builtin_options()) : nullptr;
11806 }
11807 const tflite::LogSoftmaxOptions *builtin_options_as_LogSoftmaxOptions() const {
11808 return builtin_options_type() == tflite::BuiltinOptions_LogSoftmaxOptions ? static_cast<const tflite::LogSoftmaxOptions *>(builtin_options()) : nullptr;
11809 }
11810 const tflite::CastOptions *builtin_options_as_CastOptions() const {
11811 return builtin_options_type() == tflite::BuiltinOptions_CastOptions ? static_cast<const tflite::CastOptions *>(builtin_options()) : nullptr;
11812 }
11813 const tflite::DequantizeOptions *builtin_options_as_DequantizeOptions() const {
11814 return builtin_options_type() == tflite::BuiltinOptions_DequantizeOptions ? static_cast<const tflite::DequantizeOptions *>(builtin_options()) : nullptr;
11815 }
11816 const tflite::MaximumMinimumOptions *builtin_options_as_MaximumMinimumOptions() const {
11817 return builtin_options_type() == tflite::BuiltinOptions_MaximumMinimumOptions ? static_cast<const tflite::MaximumMinimumOptions *>(builtin_options()) : nullptr;
11818 }
11819 const tflite::ArgMaxOptions *builtin_options_as_ArgMaxOptions() const {
11820 return builtin_options_type() == tflite::BuiltinOptions_ArgMaxOptions ? static_cast<const tflite::ArgMaxOptions *>(builtin_options()) : nullptr;
11821 }
11822 const tflite::LessOptions *builtin_options_as_LessOptions() const {
11823 return builtin_options_type() == tflite::BuiltinOptions_LessOptions ? static_cast<const tflite::LessOptions *>(builtin_options()) : nullptr;
11824 }
11825 const tflite::NegOptions *builtin_options_as_NegOptions() const {
11826 return builtin_options_type() == tflite::BuiltinOptions_NegOptions ? static_cast<const tflite::NegOptions *>(builtin_options()) : nullptr;
11827 }
11828 const tflite::PadV2Options *builtin_options_as_PadV2Options() const {
11829 return builtin_options_type() == tflite::BuiltinOptions_PadV2Options ? static_cast<const tflite::PadV2Options *>(builtin_options()) : nullptr;
11830 }
11831 const tflite::GreaterOptions *builtin_options_as_GreaterOptions() const {
11832 return builtin_options_type() == tflite::BuiltinOptions_GreaterOptions ? static_cast<const tflite::GreaterOptions *>(builtin_options()) : nullptr;
11833 }
11834 const tflite::GreaterEqualOptions *builtin_options_as_GreaterEqualOptions() const {
11835 return builtin_options_type() == tflite::BuiltinOptions_GreaterEqualOptions ? static_cast<const tflite::GreaterEqualOptions *>(builtin_options()) : nullptr;
11836 }
11837 const tflite::LessEqualOptions *builtin_options_as_LessEqualOptions() const {
11838 return builtin_options_type() == tflite::BuiltinOptions_LessEqualOptions ? static_cast<const tflite::LessEqualOptions *>(builtin_options()) : nullptr;
11839 }
11840 const tflite::SelectOptions *builtin_options_as_SelectOptions() const {
11841 return builtin_options_type() == tflite::BuiltinOptions_SelectOptions ? static_cast<const tflite::SelectOptions *>(builtin_options()) : nullptr;
11842 }
11843 const tflite::SliceOptions *builtin_options_as_SliceOptions() const {
11844 return builtin_options_type() == tflite::BuiltinOptions_SliceOptions ? static_cast<const tflite::SliceOptions *>(builtin_options()) : nullptr;
11845 }
11846 const tflite::TransposeConvOptions *builtin_options_as_TransposeConvOptions() const {
11847 return builtin_options_type() == tflite::BuiltinOptions_TransposeConvOptions ? static_cast<const tflite::TransposeConvOptions *>(builtin_options()) : nullptr;
11848 }
11849 const tflite::SparseToDenseOptions *builtin_options_as_SparseToDenseOptions() const {
11850 return builtin_options_type() == tflite::BuiltinOptions_SparseToDenseOptions ? static_cast<const tflite::SparseToDenseOptions *>(builtin_options()) : nullptr;
11851 }
11852 const tflite::TileOptions *builtin_options_as_TileOptions() const {
11853 return builtin_options_type() == tflite::BuiltinOptions_TileOptions ? static_cast<const tflite::TileOptions *>(builtin_options()) : nullptr;
11854 }
11855 const tflite::ExpandDimsOptions *builtin_options_as_ExpandDimsOptions() const {
11856 return builtin_options_type() == tflite::BuiltinOptions_ExpandDimsOptions ? static_cast<const tflite::ExpandDimsOptions *>(builtin_options()) : nullptr;
11857 }
11858 const tflite::EqualOptions *builtin_options_as_EqualOptions() const {
11859 return builtin_options_type() == tflite::BuiltinOptions_EqualOptions ? static_cast<const tflite::EqualOptions *>(builtin_options()) : nullptr;
11860 }
11861 const tflite::NotEqualOptions *builtin_options_as_NotEqualOptions() const {
11862 return builtin_options_type() == tflite::BuiltinOptions_NotEqualOptions ? static_cast<const tflite::NotEqualOptions *>(builtin_options()) : nullptr;
11863 }
11864 const tflite::ShapeOptions *builtin_options_as_ShapeOptions() const {
11865 return builtin_options_type() == tflite::BuiltinOptions_ShapeOptions ? static_cast<const tflite::ShapeOptions *>(builtin_options()) : nullptr;
11866 }
11867 const tflite::PowOptions *builtin_options_as_PowOptions() const {
11868 return builtin_options_type() == tflite::BuiltinOptions_PowOptions ? static_cast<const tflite::PowOptions *>(builtin_options()) : nullptr;
11869 }
11870 const tflite::ArgMinOptions *builtin_options_as_ArgMinOptions() const {
11871 return builtin_options_type() == tflite::BuiltinOptions_ArgMinOptions ? static_cast<const tflite::ArgMinOptions *>(builtin_options()) : nullptr;
11872 }
11873 const tflite::FakeQuantOptions *builtin_options_as_FakeQuantOptions() const {
11874 return builtin_options_type() == tflite::BuiltinOptions_FakeQuantOptions ? static_cast<const tflite::FakeQuantOptions *>(builtin_options()) : nullptr;
11875 }
11876 const tflite::PackOptions *builtin_options_as_PackOptions() const {
11877 return builtin_options_type() == tflite::BuiltinOptions_PackOptions ? static_cast<const tflite::PackOptions *>(builtin_options()) : nullptr;
11878 }
11879 const tflite::LogicalOrOptions *builtin_options_as_LogicalOrOptions() const {
11880 return builtin_options_type() == tflite::BuiltinOptions_LogicalOrOptions ? static_cast<const tflite::LogicalOrOptions *>(builtin_options()) : nullptr;
11881 }
11882 const tflite::OneHotOptions *builtin_options_as_OneHotOptions() const {
11883 return builtin_options_type() == tflite::BuiltinOptions_OneHotOptions ? static_cast<const tflite::OneHotOptions *>(builtin_options()) : nullptr;
11884 }
11885 const tflite::LogicalAndOptions *builtin_options_as_LogicalAndOptions() const {
11886 return builtin_options_type() == tflite::BuiltinOptions_LogicalAndOptions ? static_cast<const tflite::LogicalAndOptions *>(builtin_options()) : nullptr;
11887 }
11888 const tflite::LogicalNotOptions *builtin_options_as_LogicalNotOptions() const {
11889 return builtin_options_type() == tflite::BuiltinOptions_LogicalNotOptions ? static_cast<const tflite::LogicalNotOptions *>(builtin_options()) : nullptr;
11890 }
11891 const tflite::UnpackOptions *builtin_options_as_UnpackOptions() const {
11892 return builtin_options_type() == tflite::BuiltinOptions_UnpackOptions ? static_cast<const tflite::UnpackOptions *>(builtin_options()) : nullptr;
11893 }
11894 const tflite::FloorDivOptions *builtin_options_as_FloorDivOptions() const {
11895 return builtin_options_type() == tflite::BuiltinOptions_FloorDivOptions ? static_cast<const tflite::FloorDivOptions *>(builtin_options()) : nullptr;
11896 }
11897 const tflite::SquareOptions *builtin_options_as_SquareOptions() const {
11898 return builtin_options_type() == tflite::BuiltinOptions_SquareOptions ? static_cast<const tflite::SquareOptions *>(builtin_options()) : nullptr;
11899 }
11900 const tflite::ZerosLikeOptions *builtin_options_as_ZerosLikeOptions() const {
11901 return builtin_options_type() == tflite::BuiltinOptions_ZerosLikeOptions ? static_cast<const tflite::ZerosLikeOptions *>(builtin_options()) : nullptr;
11902 }
11903 const tflite::FillOptions *builtin_options_as_FillOptions() const {
11904 return builtin_options_type() == tflite::BuiltinOptions_FillOptions ? static_cast<const tflite::FillOptions *>(builtin_options()) : nullptr;
11905 }
11906 const tflite::BidirectionalSequenceLSTMOptions *builtin_options_as_BidirectionalSequenceLSTMOptions() const {
11907 return builtin_options_type() == tflite::BuiltinOptions_BidirectionalSequenceLSTMOptions ? static_cast<const tflite::BidirectionalSequenceLSTMOptions *>(builtin_options()) : nullptr;
11908 }
11909 const tflite::BidirectionalSequenceRNNOptions *builtin_options_as_BidirectionalSequenceRNNOptions() const {
11910 return builtin_options_type() == tflite::BuiltinOptions_BidirectionalSequenceRNNOptions ? static_cast<const tflite::BidirectionalSequenceRNNOptions *>(builtin_options()) : nullptr;
11911 }
11912 const tflite::UnidirectionalSequenceLSTMOptions *builtin_options_as_UnidirectionalSequenceLSTMOptions() const {
11913 return builtin_options_type() == tflite::BuiltinOptions_UnidirectionalSequenceLSTMOptions ? static_cast<const tflite::UnidirectionalSequenceLSTMOptions *>(builtin_options()) : nullptr;
11914 }
11915 const tflite::FloorModOptions *builtin_options_as_FloorModOptions() const {
11916 return builtin_options_type() == tflite::BuiltinOptions_FloorModOptions ? static_cast<const tflite::FloorModOptions *>(builtin_options()) : nullptr;
11917 }
11918 const tflite::RangeOptions *builtin_options_as_RangeOptions() const {
11919 return builtin_options_type() == tflite::BuiltinOptions_RangeOptions ? static_cast<const tflite::RangeOptions *>(builtin_options()) : nullptr;
11920 }
11921 const tflite::ResizeNearestNeighborOptions *builtin_options_as_ResizeNearestNeighborOptions() const {
11922 return builtin_options_type() == tflite::BuiltinOptions_ResizeNearestNeighborOptions ? static_cast<const tflite::ResizeNearestNeighborOptions *>(builtin_options()) : nullptr;
11923 }
11924 const tflite::LeakyReluOptions *builtin_options_as_LeakyReluOptions() const {
11925 return builtin_options_type() == tflite::BuiltinOptions_LeakyReluOptions ? static_cast<const tflite::LeakyReluOptions *>(builtin_options()) : nullptr;
11926 }
11927 const tflite::SquaredDifferenceOptions *builtin_options_as_SquaredDifferenceOptions() const {
11928 return builtin_options_type() == tflite::BuiltinOptions_SquaredDifferenceOptions ? static_cast<const tflite::SquaredDifferenceOptions *>(builtin_options()) : nullptr;
11929 }
11930 const tflite::MirrorPadOptions *builtin_options_as_MirrorPadOptions() const {
11931 return builtin_options_type() == tflite::BuiltinOptions_MirrorPadOptions ? static_cast<const tflite::MirrorPadOptions *>(builtin_options()) : nullptr;
11932 }
11933 const tflite::AbsOptions *builtin_options_as_AbsOptions() const {
11934 return builtin_options_type() == tflite::BuiltinOptions_AbsOptions ? static_cast<const tflite::AbsOptions *>(builtin_options()) : nullptr;
11935 }
11936 const tflite::SplitVOptions *builtin_options_as_SplitVOptions() const {
11937 return builtin_options_type() == tflite::BuiltinOptions_SplitVOptions ? static_cast<const tflite::SplitVOptions *>(builtin_options()) : nullptr;
11938 }
11939 const tflite::UniqueOptions *builtin_options_as_UniqueOptions() const {
11940 return builtin_options_type() == tflite::BuiltinOptions_UniqueOptions ? static_cast<const tflite::UniqueOptions *>(builtin_options()) : nullptr;
11941 }
11942 const tflite::ReverseV2Options *builtin_options_as_ReverseV2Options() const {
11943 return builtin_options_type() == tflite::BuiltinOptions_ReverseV2Options ? static_cast<const tflite::ReverseV2Options *>(builtin_options()) : nullptr;
11944 }
11945 const tflite::AddNOptions *builtin_options_as_AddNOptions() const {
11946 return builtin_options_type() == tflite::BuiltinOptions_AddNOptions ? static_cast<const tflite::AddNOptions *>(builtin_options()) : nullptr;
11947 }
11948 const tflite::GatherNdOptions *builtin_options_as_GatherNdOptions() const {
11949 return builtin_options_type() == tflite::BuiltinOptions_GatherNdOptions ? static_cast<const tflite::GatherNdOptions *>(builtin_options()) : nullptr;
11950 }
11951 const tflite::CosOptions *builtin_options_as_CosOptions() const {
11952 return builtin_options_type() == tflite::BuiltinOptions_CosOptions ? static_cast<const tflite::CosOptions *>(builtin_options()) : nullptr;
11953 }
11954 const tflite::WhereOptions *builtin_options_as_WhereOptions() const {
11955 return builtin_options_type() == tflite::BuiltinOptions_WhereOptions ? static_cast<const tflite::WhereOptions *>(builtin_options()) : nullptr;
11956 }
11957 const tflite::RankOptions *builtin_options_as_RankOptions() const {
11958 return builtin_options_type() == tflite::BuiltinOptions_RankOptions ? static_cast<const tflite::RankOptions *>(builtin_options()) : nullptr;
11959 }
11960 const tflite::ReverseSequenceOptions *builtin_options_as_ReverseSequenceOptions() const {
11961 return builtin_options_type() == tflite::BuiltinOptions_ReverseSequenceOptions ? static_cast<const tflite::ReverseSequenceOptions *>(builtin_options()) : nullptr;
11962 }
11963 const tflite::MatrixDiagOptions *builtin_options_as_MatrixDiagOptions() const {
11964 return builtin_options_type() == tflite::BuiltinOptions_MatrixDiagOptions ? static_cast<const tflite::MatrixDiagOptions *>(builtin_options()) : nullptr;
11965 }
11966 const tflite::QuantizeOptions *builtin_options_as_QuantizeOptions() const {
11967 return builtin_options_type() == tflite::BuiltinOptions_QuantizeOptions ? static_cast<const tflite::QuantizeOptions *>(builtin_options()) : nullptr;
11968 }
11969 const tflite::MatrixSetDiagOptions *builtin_options_as_MatrixSetDiagOptions() const {
11970 return builtin_options_type() == tflite::BuiltinOptions_MatrixSetDiagOptions ? static_cast<const tflite::MatrixSetDiagOptions *>(builtin_options()) : nullptr;
11971 }
11972 const tflite::HardSwishOptions *builtin_options_as_HardSwishOptions() const {
11973 return builtin_options_type() == tflite::BuiltinOptions_HardSwishOptions ? static_cast<const tflite::HardSwishOptions *>(builtin_options()) : nullptr;
11974 }
11975 const tflite::IfOptions *builtin_options_as_IfOptions() const {
11976 return builtin_options_type() == tflite::BuiltinOptions_IfOptions ? static_cast<const tflite::IfOptions *>(builtin_options()) : nullptr;
11977 }
11978 const tflite::WhileOptions *builtin_options_as_WhileOptions() const {
11979 return builtin_options_type() == tflite::BuiltinOptions_WhileOptions ? static_cast<const tflite::WhileOptions *>(builtin_options()) : nullptr;
11980 }
11981 const tflite::DepthToSpaceOptions *builtin_options_as_DepthToSpaceOptions() const {
11982 return builtin_options_type() == tflite::BuiltinOptions_DepthToSpaceOptions ? static_cast<const tflite::DepthToSpaceOptions *>(builtin_options()) : nullptr;
11983 }
11984 const tflite::NonMaxSuppressionV4Options *builtin_options_as_NonMaxSuppressionV4Options() const {
11985 return builtin_options_type() == tflite::BuiltinOptions_NonMaxSuppressionV4Options ? static_cast<const tflite::NonMaxSuppressionV4Options *>(builtin_options()) : nullptr;
11986 }
11987 const tflite::NonMaxSuppressionV5Options *builtin_options_as_NonMaxSuppressionV5Options() const {
11988 return builtin_options_type() == tflite::BuiltinOptions_NonMaxSuppressionV5Options ? static_cast<const tflite::NonMaxSuppressionV5Options *>(builtin_options()) : nullptr;
11989 }
11990 const tflite::ScatterNdOptions *builtin_options_as_ScatterNdOptions() const {
11991 return builtin_options_type() == tflite::BuiltinOptions_ScatterNdOptions ? static_cast<const tflite::ScatterNdOptions *>(builtin_options()) : nullptr;
11992 }
11993 const tflite::SelectV2Options *builtin_options_as_SelectV2Options() const {
11994 return builtin_options_type() == tflite::BuiltinOptions_SelectV2Options ? static_cast<const tflite::SelectV2Options *>(builtin_options()) : nullptr;
11995 }
11996 const tflite::DensifyOptions *builtin_options_as_DensifyOptions() const {
11997 return builtin_options_type() == tflite::BuiltinOptions_DensifyOptions ? static_cast<const tflite::DensifyOptions *>(builtin_options()) : nullptr;
11998 }
11999 const tflite::SegmentSumOptions *builtin_options_as_SegmentSumOptions() const {
12000 return builtin_options_type() == tflite::BuiltinOptions_SegmentSumOptions ? static_cast<const tflite::SegmentSumOptions *>(builtin_options()) : nullptr;
12001 }
12002 const tflite::BatchMatMulOptions *builtin_options_as_BatchMatMulOptions() const {
12003 return builtin_options_type() == tflite::BuiltinOptions_BatchMatMulOptions ? static_cast<const tflite::BatchMatMulOptions *>(builtin_options()) : nullptr;
12004 }
12005 const tflite::CumsumOptions *builtin_options_as_CumsumOptions() const {
12006 return builtin_options_type() == tflite::BuiltinOptions_CumsumOptions ? static_cast<const tflite::CumsumOptions *>(builtin_options()) : nullptr;
12007 }
12008 const tflite::CallOnceOptions *builtin_options_as_CallOnceOptions() const {
12009 return builtin_options_type() == tflite::BuiltinOptions_CallOnceOptions ? static_cast<const tflite::CallOnceOptions *>(builtin_options()) : nullptr;
12010 }
12011 const tflite::BroadcastToOptions *builtin_options_as_BroadcastToOptions() const {
12012 return builtin_options_type() == tflite::BuiltinOptions_BroadcastToOptions ? static_cast<const tflite::BroadcastToOptions *>(builtin_options()) : nullptr;
12013 }
12014 const tflite::Rfft2dOptions *builtin_options_as_Rfft2dOptions() const {
12015 return builtin_options_type() == tflite::BuiltinOptions_Rfft2dOptions ? static_cast<const tflite::Rfft2dOptions *>(builtin_options()) : nullptr;
12016 }
12017 const tflite::Conv3DOptions *builtin_options_as_Conv3DOptions() const {
12018 return builtin_options_type() == tflite::BuiltinOptions_Conv3DOptions ? static_cast<const tflite::Conv3DOptions *>(builtin_options()) : nullptr;
12019 }
12020 const tflite::HashtableOptions *builtin_options_as_HashtableOptions() const {
12021 return builtin_options_type() == tflite::BuiltinOptions_HashtableOptions ? static_cast<const tflite::HashtableOptions *>(builtin_options()) : nullptr;
12022 }
12023 const tflite::HashtableFindOptions *builtin_options_as_HashtableFindOptions() const {
12024 return builtin_options_type() == tflite::BuiltinOptions_HashtableFindOptions ? static_cast<const tflite::HashtableFindOptions *>(builtin_options()) : nullptr;
12025 }
12026 const tflite::HashtableImportOptions *builtin_options_as_HashtableImportOptions() const {
12027 return builtin_options_type() == tflite::BuiltinOptions_HashtableImportOptions ? static_cast<const tflite::HashtableImportOptions *>(builtin_options()) : nullptr;
12028 }
12029 const tflite::HashtableSizeOptions *builtin_options_as_HashtableSizeOptions() const {
12030 return builtin_options_type() == tflite::BuiltinOptions_HashtableSizeOptions ? static_cast<const tflite::HashtableSizeOptions *>(builtin_options()) : nullptr;
12031 }
12032 const tflite::VarHandleOptions *builtin_options_as_VarHandleOptions() const {
12033 return builtin_options_type() == tflite::BuiltinOptions_VarHandleOptions ? static_cast<const tflite::VarHandleOptions *>(builtin_options()) : nullptr;
12034 }
12035 const tflite::ReadVariableOptions *builtin_options_as_ReadVariableOptions() const {
12036 return builtin_options_type() == tflite::BuiltinOptions_ReadVariableOptions ? static_cast<const tflite::ReadVariableOptions *>(builtin_options()) : nullptr;
12037 }
12038 const tflite::AssignVariableOptions *builtin_options_as_AssignVariableOptions() const {
12039 return builtin_options_type() == tflite::BuiltinOptions_AssignVariableOptions ? static_cast<const tflite::AssignVariableOptions *>(builtin_options()) : nullptr;
12040 }
12041 const tflite::RandomOptions *builtin_options_as_RandomOptions() const {
12042 return builtin_options_type() == tflite::BuiltinOptions_RandomOptions ? static_cast<const tflite::RandomOptions *>(builtin_options()) : nullptr;
12043 }
12044 const tflite::BucketizeOptions *builtin_options_as_BucketizeOptions() const {
12045 return builtin_options_type() == tflite::BuiltinOptions_BucketizeOptions ? static_cast<const tflite::BucketizeOptions *>(builtin_options()) : nullptr;
12046 }
12047 const tflite::GeluOptions *builtin_options_as_GeluOptions() const {
12048 return builtin_options_type() == tflite::BuiltinOptions_GeluOptions ? static_cast<const tflite::GeluOptions *>(builtin_options()) : nullptr;
12049 }
12050 const tflite::DynamicUpdateSliceOptions *builtin_options_as_DynamicUpdateSliceOptions() const {
12051 return builtin_options_type() == tflite::BuiltinOptions_DynamicUpdateSliceOptions ? static_cast<const tflite::DynamicUpdateSliceOptions *>(builtin_options()) : nullptr;
12052 }
12053 const tflite::UnsortedSegmentProdOptions *builtin_options_as_UnsortedSegmentProdOptions() const {
12054 return builtin_options_type() == tflite::BuiltinOptions_UnsortedSegmentProdOptions ? static_cast<const tflite::UnsortedSegmentProdOptions *>(builtin_options()) : nullptr;
12055 }
12056 const tflite::UnsortedSegmentMaxOptions *builtin_options_as_UnsortedSegmentMaxOptions() const {
12057 return builtin_options_type() == tflite::BuiltinOptions_UnsortedSegmentMaxOptions ? static_cast<const tflite::UnsortedSegmentMaxOptions *>(builtin_options()) : nullptr;
12058 }
12059 const tflite::UnsortedSegmentMinOptions *builtin_options_as_UnsortedSegmentMinOptions() const {
12060 return builtin_options_type() == tflite::BuiltinOptions_UnsortedSegmentMinOptions ? static_cast<const tflite::UnsortedSegmentMinOptions *>(builtin_options()) : nullptr;
12061 }
12062 const tflite::UnsortedSegmentSumOptions *builtin_options_as_UnsortedSegmentSumOptions() const {
12063 return builtin_options_type() == tflite::BuiltinOptions_UnsortedSegmentSumOptions ? static_cast<const tflite::UnsortedSegmentSumOptions *>(builtin_options()) : nullptr;
12064 }
12065 const tflite::ATan2Options *builtin_options_as_ATan2Options() const {
12066 return builtin_options_type() == tflite::BuiltinOptions_ATan2Options ? static_cast<const tflite::ATan2Options *>(builtin_options()) : nullptr;
12067 }
12068 const tflite::SignOptions *builtin_options_as_SignOptions() const {
12069 return builtin_options_type() == tflite::BuiltinOptions_SignOptions ? static_cast<const tflite::SignOptions *>(builtin_options()) : nullptr;
12070 }
12072 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS);
12073 }
12075 return static_cast<tflite::CustomOptionsFormat>(GetField<int8_t>(VT_CUSTOM_OPTIONS_FORMAT, 0));
12076 }
12078 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MUTATING_VARIABLE_INPUTS);
12079 }
12081 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INTERMEDIATES);
12082 }
12083 bool Verify(flatbuffers::Verifier &verifier) const {
12084 return VerifyTableStart(verifier) &&
12085 VerifyField<uint32_t>(verifier, VT_OPCODE_INDEX, 4) &&
12086 VerifyOffset(verifier, VT_INPUTS) &&
12087 verifier.VerifyVector(inputs()) &&
12088 VerifyOffset(verifier, VT_OUTPUTS) &&
12089 verifier.VerifyVector(outputs()) &&
12090 VerifyField<uint8_t>(verifier, VT_BUILTIN_OPTIONS_TYPE, 1) &&
12091 VerifyOffset(verifier, VT_BUILTIN_OPTIONS) &&
12092 VerifyBuiltinOptions(verifier, builtin_options(), builtin_options_type()) &&
12093 VerifyOffset(verifier, VT_CUSTOM_OPTIONS) &&
12094 verifier.VerifyVector(custom_options()) &&
12095 VerifyField<int8_t>(verifier, VT_CUSTOM_OPTIONS_FORMAT, 1) &&
12096 VerifyOffset(verifier, VT_MUTATING_VARIABLE_INPUTS) &&
12097 verifier.VerifyVector(mutating_variable_inputs()) &&
12098 VerifyOffset(verifier, VT_INTERMEDIATES) &&
12099 verifier.VerifyVector(intermediates()) &&
12100 verifier.EndTable();
12101 }
12102 OperatorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12103 void UnPackTo(OperatorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12104 static flatbuffers::Offset<Operator> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12105};
12106
12107template<> inline const tflite::Conv2DOptions *Operator::builtin_options_as<tflite::Conv2DOptions>() const {
12108 return builtin_options_as_Conv2DOptions();
12109}
12110
12111template<> inline const tflite::DepthwiseConv2DOptions *Operator::builtin_options_as<tflite::DepthwiseConv2DOptions>() const {
12112 return builtin_options_as_DepthwiseConv2DOptions();
12113}
12114
12115template<> inline const tflite::ConcatEmbeddingsOptions *Operator::builtin_options_as<tflite::ConcatEmbeddingsOptions>() const {
12116 return builtin_options_as_ConcatEmbeddingsOptions();
12117}
12118
12119template<> inline const tflite::LSHProjectionOptions *Operator::builtin_options_as<tflite::LSHProjectionOptions>() const {
12120 return builtin_options_as_LSHProjectionOptions();
12121}
12122
12123template<> inline const tflite::Pool2DOptions *Operator::builtin_options_as<tflite::Pool2DOptions>() const {
12124 return builtin_options_as_Pool2DOptions();
12125}
12126
12127template<> inline const tflite::SVDFOptions *Operator::builtin_options_as<tflite::SVDFOptions>() const {
12128 return builtin_options_as_SVDFOptions();
12129}
12130
12131template<> inline const tflite::RNNOptions *Operator::builtin_options_as<tflite::RNNOptions>() const {
12132 return builtin_options_as_RNNOptions();
12133}
12134
12135template<> inline const tflite::FullyConnectedOptions *Operator::builtin_options_as<tflite::FullyConnectedOptions>() const {
12136 return builtin_options_as_FullyConnectedOptions();
12137}
12138
12139template<> inline const tflite::SoftmaxOptions *Operator::builtin_options_as<tflite::SoftmaxOptions>() const {
12140 return builtin_options_as_SoftmaxOptions();
12141}
12142
12143template<> inline const tflite::ConcatenationOptions *Operator::builtin_options_as<tflite::ConcatenationOptions>() const {
12144 return builtin_options_as_ConcatenationOptions();
12145}
12146
12147template<> inline const tflite::AddOptions *Operator::builtin_options_as<tflite::AddOptions>() const {
12148 return builtin_options_as_AddOptions();
12149}
12150
12151template<> inline const tflite::L2NormOptions *Operator::builtin_options_as<tflite::L2NormOptions>() const {
12152 return builtin_options_as_L2NormOptions();
12153}
12154
12155template<> inline const tflite::LocalResponseNormalizationOptions *Operator::builtin_options_as<tflite::LocalResponseNormalizationOptions>() const {
12156 return builtin_options_as_LocalResponseNormalizationOptions();
12157}
12158
12159template<> inline const tflite::LSTMOptions *Operator::builtin_options_as<tflite::LSTMOptions>() const {
12160 return builtin_options_as_LSTMOptions();
12161}
12162
12163template<> inline const tflite::ResizeBilinearOptions *Operator::builtin_options_as<tflite::ResizeBilinearOptions>() const {
12164 return builtin_options_as_ResizeBilinearOptions();
12165}
12166
12167template<> inline const tflite::CallOptions *Operator::builtin_options_as<tflite::CallOptions>() const {
12168 return builtin_options_as_CallOptions();
12169}
12170
12171template<> inline const tflite::ReshapeOptions *Operator::builtin_options_as<tflite::ReshapeOptions>() const {
12172 return builtin_options_as_ReshapeOptions();
12173}
12174
12175template<> inline const tflite::SkipGramOptions *Operator::builtin_options_as<tflite::SkipGramOptions>() const {
12176 return builtin_options_as_SkipGramOptions();
12177}
12178
12179template<> inline const tflite::SpaceToDepthOptions *Operator::builtin_options_as<tflite::SpaceToDepthOptions>() const {
12180 return builtin_options_as_SpaceToDepthOptions();
12181}
12182
12183template<> inline const tflite::EmbeddingLookupSparseOptions *Operator::builtin_options_as<tflite::EmbeddingLookupSparseOptions>() const {
12184 return builtin_options_as_EmbeddingLookupSparseOptions();
12185}
12186
12187template<> inline const tflite::MulOptions *Operator::builtin_options_as<tflite::MulOptions>() const {
12188 return builtin_options_as_MulOptions();
12189}
12190
12191template<> inline const tflite::PadOptions *Operator::builtin_options_as<tflite::PadOptions>() const {
12192 return builtin_options_as_PadOptions();
12193}
12194
12195template<> inline const tflite::GatherOptions *Operator::builtin_options_as<tflite::GatherOptions>() const {
12196 return builtin_options_as_GatherOptions();
12197}
12198
12199template<> inline const tflite::BatchToSpaceNDOptions *Operator::builtin_options_as<tflite::BatchToSpaceNDOptions>() const {
12200 return builtin_options_as_BatchToSpaceNDOptions();
12201}
12202
12203template<> inline const tflite::SpaceToBatchNDOptions *Operator::builtin_options_as<tflite::SpaceToBatchNDOptions>() const {
12204 return builtin_options_as_SpaceToBatchNDOptions();
12205}
12206
12207template<> inline const tflite::TransposeOptions *Operator::builtin_options_as<tflite::TransposeOptions>() const {
12208 return builtin_options_as_TransposeOptions();
12209}
12210
12211template<> inline const tflite::ReducerOptions *Operator::builtin_options_as<tflite::ReducerOptions>() const {
12212 return builtin_options_as_ReducerOptions();
12213}
12214
12215template<> inline const tflite::SubOptions *Operator::builtin_options_as<tflite::SubOptions>() const {
12216 return builtin_options_as_SubOptions();
12217}
12218
12219template<> inline const tflite::DivOptions *Operator::builtin_options_as<tflite::DivOptions>() const {
12220 return builtin_options_as_DivOptions();
12221}
12222
12223template<> inline const tflite::SqueezeOptions *Operator::builtin_options_as<tflite::SqueezeOptions>() const {
12224 return builtin_options_as_SqueezeOptions();
12225}
12226
12227template<> inline const tflite::SequenceRNNOptions *Operator::builtin_options_as<tflite::SequenceRNNOptions>() const {
12228 return builtin_options_as_SequenceRNNOptions();
12229}
12230
12231template<> inline const tflite::StridedSliceOptions *Operator::builtin_options_as<tflite::StridedSliceOptions>() const {
12232 return builtin_options_as_StridedSliceOptions();
12233}
12234
12235template<> inline const tflite::ExpOptions *Operator::builtin_options_as<tflite::ExpOptions>() const {
12236 return builtin_options_as_ExpOptions();
12237}
12238
12239template<> inline const tflite::TopKV2Options *Operator::builtin_options_as<tflite::TopKV2Options>() const {
12240 return builtin_options_as_TopKV2Options();
12241}
12242
12243template<> inline const tflite::SplitOptions *Operator::builtin_options_as<tflite::SplitOptions>() const {
12244 return builtin_options_as_SplitOptions();
12245}
12246
12247template<> inline const tflite::LogSoftmaxOptions *Operator::builtin_options_as<tflite::LogSoftmaxOptions>() const {
12248 return builtin_options_as_LogSoftmaxOptions();
12249}
12250
12251template<> inline const tflite::CastOptions *Operator::builtin_options_as<tflite::CastOptions>() const {
12252 return builtin_options_as_CastOptions();
12253}
12254
12255template<> inline const tflite::DequantizeOptions *Operator::builtin_options_as<tflite::DequantizeOptions>() const {
12256 return builtin_options_as_DequantizeOptions();
12257}
12258
12259template<> inline const tflite::MaximumMinimumOptions *Operator::builtin_options_as<tflite::MaximumMinimumOptions>() const {
12260 return builtin_options_as_MaximumMinimumOptions();
12261}
12262
12263template<> inline const tflite::ArgMaxOptions *Operator::builtin_options_as<tflite::ArgMaxOptions>() const {
12264 return builtin_options_as_ArgMaxOptions();
12265}
12266
12267template<> inline const tflite::LessOptions *Operator::builtin_options_as<tflite::LessOptions>() const {
12268 return builtin_options_as_LessOptions();
12269}
12270
12271template<> inline const tflite::NegOptions *Operator::builtin_options_as<tflite::NegOptions>() const {
12272 return builtin_options_as_NegOptions();
12273}
12274
12275template<> inline const tflite::PadV2Options *Operator::builtin_options_as<tflite::PadV2Options>() const {
12276 return builtin_options_as_PadV2Options();
12277}
12278
12279template<> inline const tflite::GreaterOptions *Operator::builtin_options_as<tflite::GreaterOptions>() const {
12280 return builtin_options_as_GreaterOptions();
12281}
12282
12283template<> inline const tflite::GreaterEqualOptions *Operator::builtin_options_as<tflite::GreaterEqualOptions>() const {
12284 return builtin_options_as_GreaterEqualOptions();
12285}
12286
12287template<> inline const tflite::LessEqualOptions *Operator::builtin_options_as<tflite::LessEqualOptions>() const {
12288 return builtin_options_as_LessEqualOptions();
12289}
12290
12291template<> inline const tflite::SelectOptions *Operator::builtin_options_as<tflite::SelectOptions>() const {
12292 return builtin_options_as_SelectOptions();
12293}
12294
12295template<> inline const tflite::SliceOptions *Operator::builtin_options_as<tflite::SliceOptions>() const {
12296 return builtin_options_as_SliceOptions();
12297}
12298
12299template<> inline const tflite::TransposeConvOptions *Operator::builtin_options_as<tflite::TransposeConvOptions>() const {
12300 return builtin_options_as_TransposeConvOptions();
12301}
12302
12303template<> inline const tflite::SparseToDenseOptions *Operator::builtin_options_as<tflite::SparseToDenseOptions>() const {
12304 return builtin_options_as_SparseToDenseOptions();
12305}
12306
12307template<> inline const tflite::TileOptions *Operator::builtin_options_as<tflite::TileOptions>() const {
12308 return builtin_options_as_TileOptions();
12309}
12310
12311template<> inline const tflite::ExpandDimsOptions *Operator::builtin_options_as<tflite::ExpandDimsOptions>() const {
12312 return builtin_options_as_ExpandDimsOptions();
12313}
12314
12315template<> inline const tflite::EqualOptions *Operator::builtin_options_as<tflite::EqualOptions>() const {
12316 return builtin_options_as_EqualOptions();
12317}
12318
12319template<> inline const tflite::NotEqualOptions *Operator::builtin_options_as<tflite::NotEqualOptions>() const {
12320 return builtin_options_as_NotEqualOptions();
12321}
12322
12323template<> inline const tflite::ShapeOptions *Operator::builtin_options_as<tflite::ShapeOptions>() const {
12324 return builtin_options_as_ShapeOptions();
12325}
12326
12327template<> inline const tflite::PowOptions *Operator::builtin_options_as<tflite::PowOptions>() const {
12328 return builtin_options_as_PowOptions();
12329}
12330
12331template<> inline const tflite::ArgMinOptions *Operator::builtin_options_as<tflite::ArgMinOptions>() const {
12332 return builtin_options_as_ArgMinOptions();
12333}
12334
12335template<> inline const tflite::FakeQuantOptions *Operator::builtin_options_as<tflite::FakeQuantOptions>() const {
12336 return builtin_options_as_FakeQuantOptions();
12337}
12338
12339template<> inline const tflite::PackOptions *Operator::builtin_options_as<tflite::PackOptions>() const {
12340 return builtin_options_as_PackOptions();
12341}
12342
12343template<> inline const tflite::LogicalOrOptions *Operator::builtin_options_as<tflite::LogicalOrOptions>() const {
12344 return builtin_options_as_LogicalOrOptions();
12345}
12346
12347template<> inline const tflite::OneHotOptions *Operator::builtin_options_as<tflite::OneHotOptions>() const {
12348 return builtin_options_as_OneHotOptions();
12349}
12350
12351template<> inline const tflite::LogicalAndOptions *Operator::builtin_options_as<tflite::LogicalAndOptions>() const {
12352 return builtin_options_as_LogicalAndOptions();
12353}
12354
12355template<> inline const tflite::LogicalNotOptions *Operator::builtin_options_as<tflite::LogicalNotOptions>() const {
12356 return builtin_options_as_LogicalNotOptions();
12357}
12358
12359template<> inline const tflite::UnpackOptions *Operator::builtin_options_as<tflite::UnpackOptions>() const {
12360 return builtin_options_as_UnpackOptions();
12361}
12362
12363template<> inline const tflite::FloorDivOptions *Operator::builtin_options_as<tflite::FloorDivOptions>() const {
12364 return builtin_options_as_FloorDivOptions();
12365}
12366
12367template<> inline const tflite::SquareOptions *Operator::builtin_options_as<tflite::SquareOptions>() const {
12368 return builtin_options_as_SquareOptions();
12369}
12370
12371template<> inline const tflite::ZerosLikeOptions *Operator::builtin_options_as<tflite::ZerosLikeOptions>() const {
12372 return builtin_options_as_ZerosLikeOptions();
12373}
12374
12375template<> inline const tflite::FillOptions *Operator::builtin_options_as<tflite::FillOptions>() const {
12376 return builtin_options_as_FillOptions();
12377}
12378
12379template<> inline const tflite::BidirectionalSequenceLSTMOptions *Operator::builtin_options_as<tflite::BidirectionalSequenceLSTMOptions>() const {
12380 return builtin_options_as_BidirectionalSequenceLSTMOptions();
12381}
12382
12383template<> inline const tflite::BidirectionalSequenceRNNOptions *Operator::builtin_options_as<tflite::BidirectionalSequenceRNNOptions>() const {
12384 return builtin_options_as_BidirectionalSequenceRNNOptions();
12385}
12386
12387template<> inline const tflite::UnidirectionalSequenceLSTMOptions *Operator::builtin_options_as<tflite::UnidirectionalSequenceLSTMOptions>() const {
12388 return builtin_options_as_UnidirectionalSequenceLSTMOptions();
12389}
12390
12391template<> inline const tflite::FloorModOptions *Operator::builtin_options_as<tflite::FloorModOptions>() const {
12392 return builtin_options_as_FloorModOptions();
12393}
12394
12395template<> inline const tflite::RangeOptions *Operator::builtin_options_as<tflite::RangeOptions>() const {
12396 return builtin_options_as_RangeOptions();
12397}
12398
12399template<> inline const tflite::ResizeNearestNeighborOptions *Operator::builtin_options_as<tflite::ResizeNearestNeighborOptions>() const {
12400 return builtin_options_as_ResizeNearestNeighborOptions();
12401}
12402
12403template<> inline const tflite::LeakyReluOptions *Operator::builtin_options_as<tflite::LeakyReluOptions>() const {
12404 return builtin_options_as_LeakyReluOptions();
12405}
12406
12407template<> inline const tflite::SquaredDifferenceOptions *Operator::builtin_options_as<tflite::SquaredDifferenceOptions>() const {
12408 return builtin_options_as_SquaredDifferenceOptions();
12409}
12410
12411template<> inline const tflite::MirrorPadOptions *Operator::builtin_options_as<tflite::MirrorPadOptions>() const {
12412 return builtin_options_as_MirrorPadOptions();
12413}
12414
12415template<> inline const tflite::AbsOptions *Operator::builtin_options_as<tflite::AbsOptions>() const {
12416 return builtin_options_as_AbsOptions();
12417}
12418
12419template<> inline const tflite::SplitVOptions *Operator::builtin_options_as<tflite::SplitVOptions>() const {
12420 return builtin_options_as_SplitVOptions();
12421}
12422
12423template<> inline const tflite::UniqueOptions *Operator::builtin_options_as<tflite::UniqueOptions>() const {
12424 return builtin_options_as_UniqueOptions();
12425}
12426
12427template<> inline const tflite::ReverseV2Options *Operator::builtin_options_as<tflite::ReverseV2Options>() const {
12428 return builtin_options_as_ReverseV2Options();
12429}
12430
12431template<> inline const tflite::AddNOptions *Operator::builtin_options_as<tflite::AddNOptions>() const {
12432 return builtin_options_as_AddNOptions();
12433}
12434
12435template<> inline const tflite::GatherNdOptions *Operator::builtin_options_as<tflite::GatherNdOptions>() const {
12436 return builtin_options_as_GatherNdOptions();
12437}
12438
12439template<> inline const tflite::CosOptions *Operator::builtin_options_as<tflite::CosOptions>() const {
12440 return builtin_options_as_CosOptions();
12441}
12442
12443template<> inline const tflite::WhereOptions *Operator::builtin_options_as<tflite::WhereOptions>() const {
12444 return builtin_options_as_WhereOptions();
12445}
12446
12447template<> inline const tflite::RankOptions *Operator::builtin_options_as<tflite::RankOptions>() const {
12448 return builtin_options_as_RankOptions();
12449}
12450
12451template<> inline const tflite::ReverseSequenceOptions *Operator::builtin_options_as<tflite::ReverseSequenceOptions>() const {
12452 return builtin_options_as_ReverseSequenceOptions();
12453}
12454
12455template<> inline const tflite::MatrixDiagOptions *Operator::builtin_options_as<tflite::MatrixDiagOptions>() const {
12456 return builtin_options_as_MatrixDiagOptions();
12457}
12458
12459template<> inline const tflite::QuantizeOptions *Operator::builtin_options_as<tflite::QuantizeOptions>() const {
12460 return builtin_options_as_QuantizeOptions();
12461}
12462
12463template<> inline const tflite::MatrixSetDiagOptions *Operator::builtin_options_as<tflite::MatrixSetDiagOptions>() const {
12464 return builtin_options_as_MatrixSetDiagOptions();
12465}
12466
12467template<> inline const tflite::HardSwishOptions *Operator::builtin_options_as<tflite::HardSwishOptions>() const {
12468 return builtin_options_as_HardSwishOptions();
12469}
12470
12471template<> inline const tflite::IfOptions *Operator::builtin_options_as<tflite::IfOptions>() const {
12472 return builtin_options_as_IfOptions();
12473}
12474
12475template<> inline const tflite::WhileOptions *Operator::builtin_options_as<tflite::WhileOptions>() const {
12476 return builtin_options_as_WhileOptions();
12477}
12478
12479template<> inline const tflite::DepthToSpaceOptions *Operator::builtin_options_as<tflite::DepthToSpaceOptions>() const {
12480 return builtin_options_as_DepthToSpaceOptions();
12481}
12482
12483template<> inline const tflite::NonMaxSuppressionV4Options *Operator::builtin_options_as<tflite::NonMaxSuppressionV4Options>() const {
12484 return builtin_options_as_NonMaxSuppressionV4Options();
12485}
12486
12487template<> inline const tflite::NonMaxSuppressionV5Options *Operator::builtin_options_as<tflite::NonMaxSuppressionV5Options>() const {
12488 return builtin_options_as_NonMaxSuppressionV5Options();
12489}
12490
12491template<> inline const tflite::ScatterNdOptions *Operator::builtin_options_as<tflite::ScatterNdOptions>() const {
12492 return builtin_options_as_ScatterNdOptions();
12493}
12494
12495template<> inline const tflite::SelectV2Options *Operator::builtin_options_as<tflite::SelectV2Options>() const {
12496 return builtin_options_as_SelectV2Options();
12497}
12498
12499template<> inline const tflite::DensifyOptions *Operator::builtin_options_as<tflite::DensifyOptions>() const {
12500 return builtin_options_as_DensifyOptions();
12501}
12502
12503template<> inline const tflite::SegmentSumOptions *Operator::builtin_options_as<tflite::SegmentSumOptions>() const {
12504 return builtin_options_as_SegmentSumOptions();
12505}
12506
12507template<> inline const tflite::BatchMatMulOptions *Operator::builtin_options_as<tflite::BatchMatMulOptions>() const {
12508 return builtin_options_as_BatchMatMulOptions();
12509}
12510
12511template<> inline const tflite::CumsumOptions *Operator::builtin_options_as<tflite::CumsumOptions>() const {
12512 return builtin_options_as_CumsumOptions();
12513}
12514
12515template<> inline const tflite::CallOnceOptions *Operator::builtin_options_as<tflite::CallOnceOptions>() const {
12516 return builtin_options_as_CallOnceOptions();
12517}
12518
12519template<> inline const tflite::BroadcastToOptions *Operator::builtin_options_as<tflite::BroadcastToOptions>() const {
12520 return builtin_options_as_BroadcastToOptions();
12521}
12522
12523template<> inline const tflite::Rfft2dOptions *Operator::builtin_options_as<tflite::Rfft2dOptions>() const {
12524 return builtin_options_as_Rfft2dOptions();
12525}
12526
12527template<> inline const tflite::Conv3DOptions *Operator::builtin_options_as<tflite::Conv3DOptions>() const {
12528 return builtin_options_as_Conv3DOptions();
12529}
12530
12531template<> inline const tflite::HashtableOptions *Operator::builtin_options_as<tflite::HashtableOptions>() const {
12532 return builtin_options_as_HashtableOptions();
12533}
12534
12535template<> inline const tflite::HashtableFindOptions *Operator::builtin_options_as<tflite::HashtableFindOptions>() const {
12536 return builtin_options_as_HashtableFindOptions();
12537}
12538
12539template<> inline const tflite::HashtableImportOptions *Operator::builtin_options_as<tflite::HashtableImportOptions>() const {
12540 return builtin_options_as_HashtableImportOptions();
12541}
12542
12543template<> inline const tflite::HashtableSizeOptions *Operator::builtin_options_as<tflite::HashtableSizeOptions>() const {
12544 return builtin_options_as_HashtableSizeOptions();
12545}
12546
12547template<> inline const tflite::VarHandleOptions *Operator::builtin_options_as<tflite::VarHandleOptions>() const {
12548 return builtin_options_as_VarHandleOptions();
12549}
12550
12551template<> inline const tflite::ReadVariableOptions *Operator::builtin_options_as<tflite::ReadVariableOptions>() const {
12552 return builtin_options_as_ReadVariableOptions();
12553}
12554
12555template<> inline const tflite::AssignVariableOptions *Operator::builtin_options_as<tflite::AssignVariableOptions>() const {
12556 return builtin_options_as_AssignVariableOptions();
12557}
12558
12559template<> inline const tflite::RandomOptions *Operator::builtin_options_as<tflite::RandomOptions>() const {
12560 return builtin_options_as_RandomOptions();
12561}
12562
12563template<> inline const tflite::BucketizeOptions *Operator::builtin_options_as<tflite::BucketizeOptions>() const {
12564 return builtin_options_as_BucketizeOptions();
12565}
12566
12567template<> inline const tflite::GeluOptions *Operator::builtin_options_as<tflite::GeluOptions>() const {
12568 return builtin_options_as_GeluOptions();
12569}
12570
12571template<> inline const tflite::DynamicUpdateSliceOptions *Operator::builtin_options_as<tflite::DynamicUpdateSliceOptions>() const {
12572 return builtin_options_as_DynamicUpdateSliceOptions();
12573}
12574
12575template<> inline const tflite::UnsortedSegmentProdOptions *Operator::builtin_options_as<tflite::UnsortedSegmentProdOptions>() const {
12576 return builtin_options_as_UnsortedSegmentProdOptions();
12577}
12578
12579template<> inline const tflite::UnsortedSegmentMaxOptions *Operator::builtin_options_as<tflite::UnsortedSegmentMaxOptions>() const {
12580 return builtin_options_as_UnsortedSegmentMaxOptions();
12581}
12582
12583template<> inline const tflite::UnsortedSegmentMinOptions *Operator::builtin_options_as<tflite::UnsortedSegmentMinOptions>() const {
12584 return builtin_options_as_UnsortedSegmentMinOptions();
12585}
12586
12587template<> inline const tflite::UnsortedSegmentSumOptions *Operator::builtin_options_as<tflite::UnsortedSegmentSumOptions>() const {
12588 return builtin_options_as_UnsortedSegmentSumOptions();
12589}
12590
12591template<> inline const tflite::ATan2Options *Operator::builtin_options_as<tflite::ATan2Options>() const {
12592 return builtin_options_as_ATan2Options();
12593}
12594
12595template<> inline const tflite::SignOptions *Operator::builtin_options_as<tflite::SignOptions>() const {
12596 return builtin_options_as_SignOptions();
12597}
12598
12599struct OperatorBuilder {
12600 typedef Operator Table;
12602 flatbuffers::uoffset_t start_;
12603 void add_opcode_index(uint32_t opcode_index) {
12604 fbb_.AddElement<uint32_t>(Operator::VT_OPCODE_INDEX, opcode_index, 0);
12605 }
12607 fbb_.AddOffset(Operator::VT_INPUTS, inputs);
12608 }
12610 fbb_.AddOffset(Operator::VT_OUTPUTS, outputs);
12611 }
12613 fbb_.AddElement<uint8_t>(Operator::VT_BUILTIN_OPTIONS_TYPE, static_cast<uint8_t>(builtin_options_type), 0);
12614 }
12615 void add_builtin_options(flatbuffers::Offset<void> builtin_options) {
12616 fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS, builtin_options);
12617 }
12618 void add_custom_options(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options) {
12619 fbb_.AddOffset(Operator::VT_CUSTOM_OPTIONS, custom_options);
12620 }
12622 fbb_.AddElement<int8_t>(Operator::VT_CUSTOM_OPTIONS_FORMAT, static_cast<int8_t>(custom_options_format), 0);
12623 }
12624 void add_mutating_variable_inputs(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs) {
12625 fbb_.AddOffset(Operator::VT_MUTATING_VARIABLE_INPUTS, mutating_variable_inputs);
12626 }
12627 void add_intermediates(flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates) {
12628 fbb_.AddOffset(Operator::VT_INTERMEDIATES, intermediates);
12629 }
12631 : fbb_(_fbb) {
12632 start_ = fbb_.StartTable();
12633 }
12634 flatbuffers::Offset<Operator> Finish() {
12635 const auto end = fbb_.EndTable(start_);
12636 auto o = flatbuffers::Offset<Operator>(end);
12637 return o;
12638 }
12639};
12640
12641inline flatbuffers::Offset<Operator> CreateOperator(
12643 uint32_t opcode_index = 0,
12644 flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
12645 flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
12647 flatbuffers::Offset<void> builtin_options = 0,
12648 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options = 0,
12650 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs = 0,
12651 flatbuffers::Offset<flatbuffers::Vector<int32_t>> intermediates = 0) {
12653 builder_.add_intermediates(intermediates);
12654 builder_.add_mutating_variable_inputs(mutating_variable_inputs);
12655 builder_.add_custom_options(custom_options);
12656 builder_.add_builtin_options(builtin_options);
12657 builder_.add_outputs(outputs);
12658 builder_.add_inputs(inputs);
12659 builder_.add_opcode_index(opcode_index);
12660 builder_.add_custom_options_format(custom_options_format);
12661 builder_.add_builtin_options_type(builtin_options_type);
12662 return builder_.Finish();
12663}
12664
12665inline flatbuffers::Offset<Operator> CreateOperatorDirect(
12667 uint32_t opcode_index = 0,
12668 const std::vector<int32_t> *inputs = nullptr,
12669 const std::vector<int32_t> *outputs = nullptr,
12671 flatbuffers::Offset<void> builtin_options = 0,
12672 const std::vector<uint8_t> *custom_options = nullptr,
12674 const std::vector<uint8_t> *mutating_variable_inputs = nullptr,
12675 const std::vector<int32_t> *intermediates = nullptr) {
12676 auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
12677 auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
12678 auto custom_options__ = custom_options ? _fbb.CreateVector<uint8_t>(*custom_options) : 0;
12679 auto mutating_variable_inputs__ = mutating_variable_inputs ? _fbb.CreateVector<uint8_t>(*mutating_variable_inputs) : 0;
12680 auto intermediates__ = intermediates ? _fbb.CreateVector<int32_t>(*intermediates) : 0;
12682 _fbb,
12683 opcode_index,
12684 inputs__,
12685 outputs__,
12686 builtin_options_type,
12687 builtin_options,
12688 custom_options__,
12689 custom_options_format,
12690 mutating_variable_inputs__,
12691 intermediates__);
12692}
12693
12694flatbuffers::Offset<Operator> CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12695
12696struct SubGraphT : public flatbuffers::NativeTable {
12697 typedef SubGraph TableType;
12698 std::vector<std::unique_ptr<tflite::TensorT>> tensors{};
12699 std::vector<int32_t> inputs{};
12700 std::vector<int32_t> outputs{};
12701 std::vector<std::unique_ptr<tflite::OperatorT>> operators{};
12702 std::string name{};
12703 SubGraphT() = default;
12704 SubGraphT(const SubGraphT &o);
12705 SubGraphT(SubGraphT&&) FLATBUFFERS_NOEXCEPT = default;
12706 SubGraphT &operator=(SubGraphT o) FLATBUFFERS_NOEXCEPT;
12707};
12708
12709struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
12712 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
12714 VT_INPUTS = 6,
12715 VT_OUTPUTS = 8,
12717 VT_NAME = 12
12718 };
12720 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>> *>(VT_TENSORS);
12721 }
12723 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS);
12724 }
12726 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS);
12727 }
12729 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>> *>(VT_OPERATORS);
12730 }
12731 const flatbuffers::String *name() const {
12732 return GetPointer<const flatbuffers::String *>(VT_NAME);
12733 }
12734 bool Verify(flatbuffers::Verifier &verifier) const {
12735 return VerifyTableStart(verifier) &&
12736 VerifyOffset(verifier, VT_TENSORS) &&
12737 verifier.VerifyVector(tensors()) &&
12738 verifier.VerifyVectorOfTables(tensors()) &&
12739 VerifyOffset(verifier, VT_INPUTS) &&
12740 verifier.VerifyVector(inputs()) &&
12741 VerifyOffset(verifier, VT_OUTPUTS) &&
12742 verifier.VerifyVector(outputs()) &&
12743 VerifyOffset(verifier, VT_OPERATORS) &&
12744 verifier.VerifyVector(operators()) &&
12745 verifier.VerifyVectorOfTables(operators()) &&
12746 VerifyOffset(verifier, VT_NAME) &&
12747 verifier.VerifyString(name()) &&
12748 verifier.EndTable();
12749 }
12750 SubGraphT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12751 void UnPackTo(SubGraphT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12752 static flatbuffers::Offset<SubGraph> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12753};
12754
12755struct SubGraphBuilder {
12756 typedef SubGraph Table;
12758 flatbuffers::uoffset_t start_;
12759 void add_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>>> tensors) {
12760 fbb_.AddOffset(SubGraph::VT_TENSORS, tensors);
12761 }
12763 fbb_.AddOffset(SubGraph::VT_INPUTS, inputs);
12764 }
12766 fbb_.AddOffset(SubGraph::VT_OUTPUTS, outputs);
12767 }
12768 void add_operators(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>>> operators) {
12769 fbb_.AddOffset(SubGraph::VT_OPERATORS, operators);
12770 }
12771 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
12772 fbb_.AddOffset(SubGraph::VT_NAME, name);
12773 }
12775 : fbb_(_fbb) {
12776 start_ = fbb_.StartTable();
12777 }
12778 flatbuffers::Offset<SubGraph> Finish() {
12779 const auto end = fbb_.EndTable(start_);
12780 auto o = flatbuffers::Offset<SubGraph>(end);
12781 return o;
12782 }
12783};
12784
12785inline flatbuffers::Offset<SubGraph> CreateSubGraph(
12787 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Tensor>>> tensors = 0,
12788 flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0,
12789 flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0,
12790 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Operator>>> operators = 0,
12791 flatbuffers::Offset<flatbuffers::String> name = 0) {
12793 builder_.add_name(name);
12794 builder_.add_operators(operators);
12795 builder_.add_outputs(outputs);
12796 builder_.add_inputs(inputs);
12797 builder_.add_tensors(tensors);
12798 return builder_.Finish();
12799}
12800
12801inline flatbuffers::Offset<SubGraph> CreateSubGraphDirect(
12803 const std::vector<flatbuffers::Offset<tflite::Tensor>> *tensors = nullptr,
12804 const std::vector<int32_t> *inputs = nullptr,
12805 const std::vector<int32_t> *outputs = nullptr,
12806 const std::vector<flatbuffers::Offset<tflite::Operator>> *operators = nullptr,
12807 const char *name = nullptr) {
12808 auto tensors__ = tensors ? _fbb.CreateVector<flatbuffers::Offset<tflite::Tensor>>(*tensors) : 0;
12809 auto inputs__ = inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0;
12810 auto outputs__ = outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0;
12811 auto operators__ = operators ? _fbb.CreateVector<flatbuffers::Offset<tflite::Operator>>(*operators) : 0;
12812 auto name__ = name ? _fbb.CreateString(name) : 0;
12814 _fbb,
12815 tensors__,
12816 inputs__,
12817 outputs__,
12818 operators__,
12819 name__);
12820}
12821
12822flatbuffers::Offset<SubGraph> CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12823
12824struct BufferT : public flatbuffers::NativeTable {
12825 typedef Buffer TableType;
12826 std::vector<uint8_t> data{};
12827};
12828
12829struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
12832 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
12833 VT_DATA = 4
12834 };
12836 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
12837 }
12838 bool Verify(flatbuffers::Verifier &verifier) const {
12839 return VerifyTableStart(verifier) &&
12840 VerifyOffset(verifier, VT_DATA) &&
12841 verifier.VerifyVector(data()) &&
12842 verifier.EndTable();
12843 }
12844 BufferT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12845 void UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12846 static flatbuffers::Offset<Buffer> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12847};
12848
12849struct BufferBuilder {
12850 typedef Buffer Table;
12852 flatbuffers::uoffset_t start_;
12853 void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
12854 fbb_.AddOffset(Buffer::VT_DATA, data);
12855 }
12857 : fbb_(_fbb) {
12858 start_ = fbb_.StartTable();
12859 }
12860 flatbuffers::Offset<Buffer> Finish() {
12861 const auto end = fbb_.EndTable(start_);
12862 auto o = flatbuffers::Offset<Buffer>(end);
12863 return o;
12864 }
12865};
12866
12867inline flatbuffers::Offset<Buffer> CreateBuffer(
12869 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
12870 BufferBuilder builder_(_fbb);
12871 builder_.add_data(data);
12872 return builder_.Finish();
12873}
12874
12875inline flatbuffers::Offset<Buffer> CreateBufferDirect(
12877 const std::vector<uint8_t> *data = nullptr) {
12878 if (data) { _fbb.ForceVectorAlignment(data->size(), sizeof(uint8_t), 16); }
12879 auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
12880 return tflite::CreateBuffer(
12881 _fbb,
12882 data__);
12883}
12884
12885flatbuffers::Offset<Buffer> CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12886
12887struct MetadataT : public flatbuffers::NativeTable {
12888 typedef Metadata TableType;
12889 std::string name{};
12890 uint32_t buffer = 0;
12891};
12892
12893struct Metadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
12896 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
12897 VT_NAME = 4,
12898 VT_BUFFER = 6
12899 };
12900 const flatbuffers::String *name() const {
12901 return GetPointer<const flatbuffers::String *>(VT_NAME);
12902 }
12903 uint32_t buffer() const {
12904 return GetField<uint32_t>(VT_BUFFER, 0);
12905 }
12906 bool Verify(flatbuffers::Verifier &verifier) const {
12907 return VerifyTableStart(verifier) &&
12908 VerifyOffset(verifier, VT_NAME) &&
12909 verifier.VerifyString(name()) &&
12910 VerifyField<uint32_t>(verifier, VT_BUFFER, 4) &&
12911 verifier.EndTable();
12912 }
12913 MetadataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12914 void UnPackTo(MetadataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12915 static flatbuffers::Offset<Metadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12916};
12917
12918struct MetadataBuilder {
12919 typedef Metadata Table;
12921 flatbuffers::uoffset_t start_;
12922 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
12923 fbb_.AddOffset(Metadata::VT_NAME, name);
12924 }
12925 void add_buffer(uint32_t buffer) {
12926 fbb_.AddElement<uint32_t>(Metadata::VT_BUFFER, buffer, 0);
12927 }
12929 : fbb_(_fbb) {
12930 start_ = fbb_.StartTable();
12931 }
12932 flatbuffers::Offset<Metadata> Finish() {
12933 const auto end = fbb_.EndTable(start_);
12934 auto o = flatbuffers::Offset<Metadata>(end);
12935 return o;
12936 }
12937};
12938
12939inline flatbuffers::Offset<Metadata> CreateMetadata(
12941 flatbuffers::Offset<flatbuffers::String> name = 0,
12942 uint32_t buffer = 0) {
12944 builder_.add_buffer(buffer);
12945 builder_.add_name(name);
12946 return builder_.Finish();
12947}
12948
12949inline flatbuffers::Offset<Metadata> CreateMetadataDirect(
12951 const char *name = nullptr,
12952 uint32_t buffer = 0) {
12953 auto name__ = name ? _fbb.CreateString(name) : 0;
12955 _fbb,
12956 name__,
12957 buffer);
12958}
12959
12960flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12961
12962struct TensorMapT : public flatbuffers::NativeTable {
12963 typedef TensorMap TableType;
12964 std::string name{};
12965 uint32_t tensor_index = 0;
12966};
12967
12968struct TensorMap FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
12971 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
12972 VT_NAME = 4,
12973 VT_TENSOR_INDEX = 6
12974 };
12975 const flatbuffers::String *name() const {
12976 return GetPointer<const flatbuffers::String *>(VT_NAME);
12977 }
12978 uint32_t tensor_index() const {
12979 return GetField<uint32_t>(VT_TENSOR_INDEX, 0);
12980 }
12981 bool Verify(flatbuffers::Verifier &verifier) const {
12982 return VerifyTableStart(verifier) &&
12983 VerifyOffset(verifier, VT_NAME) &&
12984 verifier.VerifyString(name()) &&
12985 VerifyField<uint32_t>(verifier, VT_TENSOR_INDEX, 4) &&
12986 verifier.EndTable();
12987 }
12988 TensorMapT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12989 void UnPackTo(TensorMapT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
12990 static flatbuffers::Offset<TensorMap> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
12991};
12992
12993struct TensorMapBuilder {
12994 typedef TensorMap Table;
12996 flatbuffers::uoffset_t start_;
12997 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
12998 fbb_.AddOffset(TensorMap::VT_NAME, name);
12999 }
13000 void add_tensor_index(uint32_t tensor_index) {
13001 fbb_.AddElement<uint32_t>(TensorMap::VT_TENSOR_INDEX, tensor_index, 0);
13002 }
13004 : fbb_(_fbb) {
13005 start_ = fbb_.StartTable();
13006 }
13007 flatbuffers::Offset<TensorMap> Finish() {
13008 const auto end = fbb_.EndTable(start_);
13009 auto o = flatbuffers::Offset<TensorMap>(end);
13010 return o;
13011 }
13012};
13013
13014inline flatbuffers::Offset<TensorMap> CreateTensorMap(
13016 flatbuffers::Offset<flatbuffers::String> name = 0,
13017 uint32_t tensor_index = 0) {
13019 builder_.add_tensor_index(tensor_index);
13020 builder_.add_name(name);
13021 return builder_.Finish();
13022}
13023
13024inline flatbuffers::Offset<TensorMap> CreateTensorMapDirect(
13026 const char *name = nullptr,
13027 uint32_t tensor_index = 0) {
13028 auto name__ = name ? _fbb.CreateString(name) : 0;
13030 _fbb,
13031 name__,
13032 tensor_index);
13033}
13034
13035flatbuffers::Offset<TensorMap> CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
13036
13037struct SignatureDefT : public flatbuffers::NativeTable {
13038 typedef SignatureDef TableType;
13039 std::vector<std::unique_ptr<tflite::TensorMapT>> inputs{};
13040 std::vector<std::unique_ptr<tflite::TensorMapT>> outputs{};
13041 std::string signature_key{};
13042 uint32_t subgraph_index = 0;
13043 SignatureDefT() = default;
13044 SignatureDefT(const SignatureDefT &o);
13045 SignatureDefT(SignatureDefT&&) FLATBUFFERS_NOEXCEPT = default;
13046 SignatureDefT &operator=(SignatureDefT o) FLATBUFFERS_NOEXCEPT;
13047};
13048
13049struct SignatureDef FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
13052 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
13053 VT_INPUTS = 4,
13054 VT_OUTPUTS = 6,
13056 VT_SUBGRAPH_INDEX = 12
13057 };
13059 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> *>(VT_INPUTS);
13060 }
13062 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>> *>(VT_OUTPUTS);
13063 }
13065 return GetPointer<const flatbuffers::String *>(VT_SIGNATURE_KEY);
13066 }
13067 uint32_t subgraph_index() const {
13068 return GetField<uint32_t>(VT_SUBGRAPH_INDEX, 0);
13069 }
13070 bool Verify(flatbuffers::Verifier &verifier) const {
13071 return VerifyTableStart(verifier) &&
13072 VerifyOffset(verifier, VT_INPUTS) &&
13073 verifier.VerifyVector(inputs()) &&
13074 verifier.VerifyVectorOfTables(inputs()) &&
13075 VerifyOffset(verifier, VT_OUTPUTS) &&
13076 verifier.VerifyVector(outputs()) &&
13077 verifier.VerifyVectorOfTables(outputs()) &&
13078 VerifyOffset(verifier, VT_SIGNATURE_KEY) &&
13079 verifier.VerifyString(signature_key()) &&
13080 VerifyField<uint32_t>(verifier, VT_SUBGRAPH_INDEX, 4) &&
13081 verifier.EndTable();
13082 }
13083 SignatureDefT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
13084 void UnPackTo(SignatureDefT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
13085 static flatbuffers::Offset<SignatureDef> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
13086};
13087
13088struct SignatureDefBuilder {
13089 typedef SignatureDef Table;
13091 flatbuffers::uoffset_t start_;
13092 void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> inputs) {
13093 fbb_.AddOffset(SignatureDef::VT_INPUTS, inputs);
13094 }
13095 void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> outputs) {
13096 fbb_.AddOffset(SignatureDef::VT_OUTPUTS, outputs);
13097 }
13098 void add_signature_key(flatbuffers::Offset<flatbuffers::String> signature_key) {
13099 fbb_.AddOffset(SignatureDef::VT_SIGNATURE_KEY, signature_key);
13100 }
13101 void add_subgraph_index(uint32_t subgraph_index) {
13102 fbb_.AddElement<uint32_t>(SignatureDef::VT_SUBGRAPH_INDEX, subgraph_index, 0);
13103 }
13105 : fbb_(_fbb) {
13106 start_ = fbb_.StartTable();
13107 }
13108 flatbuffers::Offset<SignatureDef> Finish() {
13109 const auto end = fbb_.EndTable(start_);
13110 auto o = flatbuffers::Offset<SignatureDef>(end);
13111 return o;
13112 }
13113};
13114
13115inline flatbuffers::Offset<SignatureDef> CreateSignatureDef(
13117 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> inputs = 0,
13118 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMap>>> outputs = 0,
13119 flatbuffers::Offset<flatbuffers::String> signature_key = 0,
13120 uint32_t subgraph_index = 0) {
13122 builder_.add_subgraph_index(subgraph_index);
13123 builder_.add_signature_key(signature_key);
13124 builder_.add_outputs(outputs);
13125 builder_.add_inputs(inputs);
13126 return builder_.Finish();
13127}
13128
13129inline flatbuffers::Offset<SignatureDef> CreateSignatureDefDirect(
13131 const std::vector<flatbuffers::Offset<tflite::TensorMap>> *inputs = nullptr,
13132 const std::vector<flatbuffers::Offset<tflite::TensorMap>> *outputs = nullptr,
13133 const char *signature_key = nullptr,
13134 uint32_t subgraph_index = 0) {
13135 auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>>(*inputs) : 0;
13136 auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>>(*outputs) : 0;
13137 auto signature_key__ = signature_key ? _fbb.CreateString(signature_key) : 0;
13139 _fbb,
13140 inputs__,
13141 outputs__,
13142 signature_key__,
13143 subgraph_index);
13144}
13145
13146flatbuffers::Offset<SignatureDef> CreateSignatureDef(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
13147
13148struct ModelT : public flatbuffers::NativeTable {
13149 typedef Model TableType;
13150 uint32_t version = 0;
13151 std::vector<std::unique_ptr<tflite::OperatorCodeT>> operator_codes{};
13152 std::vector<std::unique_ptr<tflite::SubGraphT>> subgraphs{};
13153 std::string description{};
13154 std::vector<std::unique_ptr<tflite::BufferT>> buffers{};
13155 std::vector<int32_t> metadata_buffer{};
13156 std::vector<std::unique_ptr<tflite::MetadataT>> metadata{};
13157 std::vector<std::unique_ptr<tflite::SignatureDefT>> signature_defs{};
13158 ModelT() = default;
13159 ModelT(const ModelT &o);
13160 ModelT(ModelT&&) FLATBUFFERS_NOEXCEPT = default;
13161 ModelT &operator=(ModelT o) FLATBUFFERS_NOEXCEPT;
13162};
13163
13164struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
13167 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
13168 VT_VERSION = 4,
13175 VT_SIGNATURE_DEFS = 18
13176 };
13177 uint32_t version() const {
13178 return GetField<uint32_t>(VT_VERSION, 0);
13179 }
13181 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>> *>(VT_OPERATOR_CODES);
13182 }
13184 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>> *>(VT_SUBGRAPHS);
13185 }
13187 return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
13188 }
13190 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>> *>(VT_BUFFERS);
13191 }
13193 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_METADATA_BUFFER);
13194 }
13196 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>> *>(VT_METADATA);
13197 }
13199 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>> *>(VT_SIGNATURE_DEFS);
13200 }
13201 bool Verify(flatbuffers::Verifier &verifier) const {
13202 return VerifyTableStart(verifier) &&
13203 VerifyField<uint32_t>(verifier, VT_VERSION, 4) &&
13204 VerifyOffset(verifier, VT_OPERATOR_CODES) &&
13205 verifier.VerifyVector(operator_codes()) &&
13206 verifier.VerifyVectorOfTables(operator_codes()) &&
13207 VerifyOffset(verifier, VT_SUBGRAPHS) &&
13208 verifier.VerifyVector(subgraphs()) &&
13209 verifier.VerifyVectorOfTables(subgraphs()) &&
13210 VerifyOffset(verifier, VT_DESCRIPTION) &&
13211 verifier.VerifyString(description()) &&
13212 VerifyOffset(verifier, VT_BUFFERS) &&
13213 verifier.VerifyVector(buffers()) &&
13214 verifier.VerifyVectorOfTables(buffers()) &&
13215 VerifyOffset(verifier, VT_METADATA_BUFFER) &&
13216 verifier.VerifyVector(metadata_buffer()) &&
13217 VerifyOffset(verifier, VT_METADATA) &&
13218 verifier.VerifyVector(metadata()) &&
13219 verifier.VerifyVectorOfTables(metadata()) &&
13220 VerifyOffset(verifier, VT_SIGNATURE_DEFS) &&
13221 verifier.VerifyVector(signature_defs()) &&
13222 verifier.VerifyVectorOfTables(signature_defs()) &&
13223 verifier.EndTable();
13224 }
13225 ModelT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
13226 void UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
13227 static flatbuffers::Offset<Model> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
13228};
13229
13230struct ModelBuilder {
13231 typedef Model Table;
13233 flatbuffers::uoffset_t start_;
13234 void add_version(uint32_t version) {
13235 fbb_.AddElement<uint32_t>(Model::VT_VERSION, version, 0);
13236 }
13237 void add_operator_codes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>>> operator_codes) {
13238 fbb_.AddOffset(Model::VT_OPERATOR_CODES, operator_codes);
13239 }
13240 void add_subgraphs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>>> subgraphs) {
13241 fbb_.AddOffset(Model::VT_SUBGRAPHS, subgraphs);
13242 }
13243 void add_description(flatbuffers::Offset<flatbuffers::String> description) {
13244 fbb_.AddOffset(Model::VT_DESCRIPTION, description);
13245 }
13246 void add_buffers(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>>> buffers) {
13247 fbb_.AddOffset(Model::VT_BUFFERS, buffers);
13248 }
13249 void add_metadata_buffer(flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer) {
13250 fbb_.AddOffset(Model::VT_METADATA_BUFFER, metadata_buffer);
13251 }
13252 void add_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>>> metadata) {
13253 fbb_.AddOffset(Model::VT_METADATA, metadata);
13254 }
13255 void add_signature_defs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>>> signature_defs) {
13256 fbb_.AddOffset(Model::VT_SIGNATURE_DEFS, signature_defs);
13257 }
13259 : fbb_(_fbb) {
13260 start_ = fbb_.StartTable();
13261 }
13262 flatbuffers::Offset<Model> Finish() {
13263 const auto end = fbb_.EndTable(start_);
13264 auto o = flatbuffers::Offset<Model>(end);
13265 return o;
13266 }
13267};
13268
13269inline flatbuffers::Offset<Model> CreateModel(
13271 uint32_t version = 0,
13272 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::OperatorCode>>> operator_codes = 0,
13273 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraph>>> subgraphs = 0,
13274 flatbuffers::Offset<flatbuffers::String> description = 0,
13275 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Buffer>>> buffers = 0,
13276 flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer = 0,
13277 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::Metadata>>> metadata = 0,
13278 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SignatureDef>>> signature_defs = 0) {
13279 ModelBuilder builder_(_fbb);
13280 builder_.add_signature_defs(signature_defs);
13281 builder_.add_metadata(metadata);
13282 builder_.add_metadata_buffer(metadata_buffer);
13283 builder_.add_buffers(buffers);
13284 builder_.add_description(description);
13285 builder_.add_subgraphs(subgraphs);
13286 builder_.add_operator_codes(operator_codes);
13287 builder_.add_version(version);
13288 return builder_.Finish();
13289}
13290
13291inline flatbuffers::Offset<Model> CreateModelDirect(
13293 uint32_t version = 0,
13294 const std::vector<flatbuffers::Offset<tflite::OperatorCode>> *operator_codes = nullptr,
13295 const std::vector<flatbuffers::Offset<tflite::SubGraph>> *subgraphs = nullptr,
13296 const char *description = nullptr,
13297 const std::vector<flatbuffers::Offset<tflite::Buffer>> *buffers = nullptr,
13298 const std::vector<int32_t> *metadata_buffer = nullptr,
13299 const std::vector<flatbuffers::Offset<tflite::Metadata>> *metadata = nullptr,
13300 const std::vector<flatbuffers::Offset<tflite::SignatureDef>> *signature_defs = nullptr) {
13301 auto operator_codes__ = operator_codes ? _fbb.CreateVector<flatbuffers::Offset<tflite::OperatorCode>>(*operator_codes) : 0;
13302 auto subgraphs__ = subgraphs ? _fbb.CreateVector<flatbuffers::Offset<tflite::SubGraph>>(*subgraphs) : 0;
13303 auto description__ = description ? _fbb.CreateString(description) : 0;
13304 auto buffers__ = buffers ? _fbb.CreateVector<flatbuffers::Offset<tflite::Buffer>>(*buffers) : 0;
13305 auto metadata_buffer__ = metadata_buffer ? _fbb.CreateVector<int32_t>(*metadata_buffer) : 0;
13306 auto metadata__ = metadata ? _fbb.CreateVector<flatbuffers::Offset<tflite::Metadata>>(*metadata) : 0;
13307 auto signature_defs__ = signature_defs ? _fbb.CreateVector<flatbuffers::Offset<tflite::SignatureDef>>(*signature_defs) : 0;
13308 return tflite::CreateModel(
13309 _fbb,
13310 version,
13311 operator_codes__,
13312 subgraphs__,
13313 description__,
13314 buffers__,
13315 metadata_buffer__,
13316 metadata__,
13317 signature_defs__);
13318}
13319
13320flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
13321
13322inline CustomQuantizationT *CustomQuantization::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13323 auto _o = std::unique_ptr<CustomQuantizationT>(new CustomQuantizationT());
13324 UnPackTo(_o.get(), _resolver);
13325 return _o.release();
13326}
13327
13328inline void CustomQuantization::UnPackTo(CustomQuantizationT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13329 (void)_o;
13330 (void)_resolver;
13331 { auto _e = custom(); if (_e) { _o->custom.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->custom.begin()); } }
13332}
13333
13334inline flatbuffers::Offset<CustomQuantization> CustomQuantization::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13335 return CreateCustomQuantization(_fbb, _o, _rehasher);
13336}
13337
13338inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13339 (void)_rehasher;
13340 (void)_o;
13341 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CustomQuantizationT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13342 _fbb.ForceVectorAlignment(_o->custom.size(), sizeof(uint8_t), 16);
13343 auto _custom = _o->custom.size() ? _fbb.CreateVector(_o->custom) : 0;
13345 _fbb,
13346 _custom);
13347}
13348
13349inline QuantizationParametersT *QuantizationParameters::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13350 auto _o = std::unique_ptr<QuantizationParametersT>(new QuantizationParametersT());
13351 UnPackTo(_o.get(), _resolver);
13352 return _o.release();
13353}
13354
13355inline void QuantizationParameters::UnPackTo(QuantizationParametersT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13356 (void)_o;
13357 (void)_resolver;
13358 { auto _e = min(); if (_e) { _o->min.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->min[_i] = _e->Get(_i); } } }
13359 { auto _e = max(); if (_e) { _o->max.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->max[_i] = _e->Get(_i); } } }
13360 { auto _e = scale(); if (_e) { _o->scale.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->scale[_i] = _e->Get(_i); } } }
13361 { auto _e = zero_point(); if (_e) { _o->zero_point.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->zero_point[_i] = _e->Get(_i); } } }
13362 { auto _e = details_type(); _o->details.type = _e; }
13363 { auto _e = details(); if (_e) _o->details.value = tflite::QuantizationDetailsUnion::UnPack(_e, details_type(), _resolver); }
13364 { auto _e = quantized_dimension(); _o->quantized_dimension = _e; }
13365}
13366
13367inline flatbuffers::Offset<QuantizationParameters> QuantizationParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13368 return CreateQuantizationParameters(_fbb, _o, _rehasher);
13369}
13370
13371inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13372 (void)_rehasher;
13373 (void)_o;
13374 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizationParametersT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13375 auto _min = _o->min.size() ? _fbb.CreateVector(_o->min) : 0;
13376 auto _max = _o->max.size() ? _fbb.CreateVector(_o->max) : 0;
13377 auto _scale = _o->scale.size() ? _fbb.CreateVector(_o->scale) : 0;
13378 auto _zero_point = _o->zero_point.size() ? _fbb.CreateVector(_o->zero_point) : 0;
13379 auto _details_type = _o->details.type;
13380 auto _details = _o->details.Pack(_fbb);
13381 auto _quantized_dimension = _o->quantized_dimension;
13383 _fbb,
13384 _min,
13385 _max,
13386 _scale,
13387 _zero_point,
13388 _details_type,
13389 _details,
13390 _quantized_dimension);
13391}
13392
13393inline Int32VectorT *Int32Vector::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13394 auto _o = std::unique_ptr<Int32VectorT>(new Int32VectorT());
13395 UnPackTo(_o.get(), _resolver);
13396 return _o.release();
13397}
13398
13399inline void Int32Vector::UnPackTo(Int32VectorT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13400 (void)_o;
13401 (void)_resolver;
13402 { auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->values[_i] = _e->Get(_i); } } }
13403}
13404
13405inline flatbuffers::Offset<Int32Vector> Int32Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13406 return CreateInt32Vector(_fbb, _o, _rehasher);
13407}
13408
13409inline flatbuffers::Offset<Int32Vector> CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13410 (void)_rehasher;
13411 (void)_o;
13412 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Int32VectorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13413 auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : 0;
13415 _fbb,
13416 _values);
13417}
13418
13419inline Uint16VectorT *Uint16Vector::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13420 auto _o = std::unique_ptr<Uint16VectorT>(new Uint16VectorT());
13421 UnPackTo(_o.get(), _resolver);
13422 return _o.release();
13423}
13424
13425inline void Uint16Vector::UnPackTo(Uint16VectorT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13426 (void)_o;
13427 (void)_resolver;
13428 { auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->values[_i] = _e->Get(_i); } } }
13429}
13430
13431inline flatbuffers::Offset<Uint16Vector> Uint16Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13432 return CreateUint16Vector(_fbb, _o, _rehasher);
13433}
13434
13435inline flatbuffers::Offset<Uint16Vector> CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13436 (void)_rehasher;
13437 (void)_o;
13438 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Uint16VectorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13439 _fbb.ForceVectorAlignment(_o->values.size(), sizeof(uint16_t), 4);
13440 auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : 0;
13442 _fbb,
13443 _values);
13444}
13445
13446inline Uint8VectorT *Uint8Vector::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13447 auto _o = std::unique_ptr<Uint8VectorT>(new Uint8VectorT());
13448 UnPackTo(_o.get(), _resolver);
13449 return _o.release();
13450}
13451
13452inline void Uint8Vector::UnPackTo(Uint8VectorT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13453 (void)_o;
13454 (void)_resolver;
13455 { auto _e = values(); if (_e) { _o->values.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->values.begin()); } }
13456}
13457
13458inline flatbuffers::Offset<Uint8Vector> Uint8Vector::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13459 return CreateUint8Vector(_fbb, _o, _rehasher);
13460}
13461
13462inline flatbuffers::Offset<Uint8Vector> CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13463 (void)_rehasher;
13464 (void)_o;
13465 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Uint8VectorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13466 _fbb.ForceVectorAlignment(_o->values.size(), sizeof(uint8_t), 4);
13467 auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : 0;
13469 _fbb,
13470 _values);
13471}
13472
13473inline DimensionMetadataT *DimensionMetadata::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13474 auto _o = std::unique_ptr<DimensionMetadataT>(new DimensionMetadataT());
13475 UnPackTo(_o.get(), _resolver);
13476 return _o.release();
13477}
13478
13479inline void DimensionMetadata::UnPackTo(DimensionMetadataT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13480 (void)_o;
13481 (void)_resolver;
13482 { auto _e = format(); _o->format = _e; }
13483 { auto _e = dense_size(); _o->dense_size = _e; }
13484 { auto _e = array_segments_type(); _o->array_segments.type = _e; }
13485 { auto _e = array_segments(); if (_e) _o->array_segments.value = tflite::SparseIndexVectorUnion::UnPack(_e, array_segments_type(), _resolver); }
13486 { auto _e = array_indices_type(); _o->array_indices.type = _e; }
13487 { auto _e = array_indices(); if (_e) _o->array_indices.value = tflite::SparseIndexVectorUnion::UnPack(_e, array_indices_type(), _resolver); }
13488}
13489
13490inline flatbuffers::Offset<DimensionMetadata> DimensionMetadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13491 return CreateDimensionMetadata(_fbb, _o, _rehasher);
13492}
13493
13494inline flatbuffers::Offset<DimensionMetadata> CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13495 (void)_rehasher;
13496 (void)_o;
13497 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DimensionMetadataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13498 auto _format = _o->format;
13499 auto _dense_size = _o->dense_size;
13500 auto _array_segments_type = _o->array_segments.type;
13501 auto _array_segments = _o->array_segments.Pack(_fbb);
13502 auto _array_indices_type = _o->array_indices.type;
13503 auto _array_indices = _o->array_indices.Pack(_fbb);
13505 _fbb,
13506 _format,
13507 _dense_size,
13508 _array_segments_type,
13509 _array_segments,
13510 _array_indices_type,
13511 _array_indices);
13512}
13513
13514inline SparsityParametersT::SparsityParametersT(const SparsityParametersT &o)
13515 : traversal_order(o.traversal_order),
13516 block_map(o.block_map) {
13517 dim_metadata.reserve(o.dim_metadata.size());
13518 for (const auto &dim_metadata_ : o.dim_metadata) { dim_metadata.emplace_back((dim_metadata_) ? new tflite::DimensionMetadataT(*dim_metadata_) : nullptr); }
13519}
13520
13522 std::swap(traversal_order, o.traversal_order);
13523 std::swap(block_map, o.block_map);
13524 std::swap(dim_metadata, o.dim_metadata);
13525 return *this;
13526}
13527
13528inline SparsityParametersT *SparsityParameters::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13529 auto _o = std::unique_ptr<SparsityParametersT>(new SparsityParametersT());
13530 UnPackTo(_o.get(), _resolver);
13531 return _o.release();
13532}
13533
13534inline void SparsityParameters::UnPackTo(SparsityParametersT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13535 (void)_o;
13536 (void)_resolver;
13537 { auto _e = traversal_order(); if (_e) { _o->traversal_order.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->traversal_order[_i] = _e->Get(_i); } } }
13538 { auto _e = block_map(); if (_e) { _o->block_map.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->block_map[_i] = _e->Get(_i); } } }
13539 { auto _e = dim_metadata(); if (_e) { _o->dim_metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->dim_metadata[_i]) { _e->Get(_i)->UnPackTo(_o->dim_metadata[_i].get(), _resolver); } else { _o->dim_metadata[_i] = std::unique_ptr<tflite::DimensionMetadataT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
13540}
13541
13542inline flatbuffers::Offset<SparsityParameters> SparsityParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13543 return CreateSparsityParameters(_fbb, _o, _rehasher);
13544}
13545
13546inline flatbuffers::Offset<SparsityParameters> CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13547 (void)_rehasher;
13548 (void)_o;
13549 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SparsityParametersT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13550 auto _traversal_order = _o->traversal_order.size() ? _fbb.CreateVector(_o->traversal_order) : 0;
13551 auto _block_map = _o->block_map.size() ? _fbb.CreateVector(_o->block_map) : 0;
13552 auto _dim_metadata = _o->dim_metadata.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::DimensionMetadata>> (_o->dim_metadata.size(), [](size_t i, _VectorArgs *__va) { return CreateDimensionMetadata(*__va->__fbb, __va->__o->dim_metadata[i].get(), __va->__rehasher); }, &_va ) : 0;
13554 _fbb,
13555 _traversal_order,
13556 _block_map,
13557 _dim_metadata);
13558}
13559
13560inline VariantSubTypeT *VariantSubType::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13561 auto _o = std::unique_ptr<VariantSubTypeT>(new VariantSubTypeT());
13562 UnPackTo(_o.get(), _resolver);
13563 return _o.release();
13564}
13565
13566inline void VariantSubType::UnPackTo(VariantSubTypeT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13567 (void)_o;
13568 (void)_resolver;
13569 { auto _e = shape(); if (_e) { _o->shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->shape[_i] = _e->Get(_i); } } }
13570 { auto _e = type(); _o->type = _e; }
13571 { auto _e = has_rank(); _o->has_rank = _e; }
13572}
13573
13574inline flatbuffers::Offset<VariantSubType> VariantSubType::Pack(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13575 return CreateVariantSubType(_fbb, _o, _rehasher);
13576}
13577
13578inline flatbuffers::Offset<VariantSubType> CreateVariantSubType(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13579 (void)_rehasher;
13580 (void)_o;
13581 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const VariantSubTypeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13582 auto _shape = _o->shape.size() ? _fbb.CreateVector(_o->shape) : 0;
13583 auto _type = _o->type;
13584 auto _has_rank = _o->has_rank;
13586 _fbb,
13587 _shape,
13588 _type,
13589 _has_rank);
13590}
13591
13593 : shape(o.shape),
13594 type(o.type),
13595 buffer(o.buffer),
13596 name(o.name),
13598 is_variable(o.is_variable),
13599 sparsity((o.sparsity) ? new tflite::SparsityParametersT(*o.sparsity) : nullptr),
13600 shape_signature(o.shape_signature),
13601 has_rank(o.has_rank) {
13602 variant_tensors.reserve(o.variant_tensors.size());
13603 for (const auto &variant_tensors_ : o.variant_tensors) { variant_tensors.emplace_back((variant_tensors_) ? new tflite::VariantSubTypeT(*variant_tensors_) : nullptr); }
13604}
13605
13606inline TensorT &TensorT::operator=(TensorT o) FLATBUFFERS_NOEXCEPT {
13607 std::swap(shape, o.shape);
13608 std::swap(type, o.type);
13609 std::swap(buffer, o.buffer);
13610 std::swap(name, o.name);
13611 std::swap(quantization, o.quantization);
13612 std::swap(is_variable, o.is_variable);
13613 std::swap(sparsity, o.sparsity);
13614 std::swap(shape_signature, o.shape_signature);
13615 std::swap(has_rank, o.has_rank);
13616 std::swap(variant_tensors, o.variant_tensors);
13617 return *this;
13618}
13619
13620inline TensorT *Tensor::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13621 auto _o = std::unique_ptr<TensorT>(new TensorT());
13622 UnPackTo(_o.get(), _resolver);
13623 return _o.release();
13624}
13625
13626inline void Tensor::UnPackTo(TensorT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13627 (void)_o;
13628 (void)_resolver;
13629 { auto _e = shape(); if (_e) { _o->shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->shape[_i] = _e->Get(_i); } } }
13630 { auto _e = type(); _o->type = _e; }
13631 { auto _e = buffer(); _o->buffer = _e; }
13632 { auto _e = name(); if (_e) _o->name = _e->str(); }
13633 { auto _e = quantization(); if (_e) { if(_o->quantization) { _e->UnPackTo(_o->quantization.get(), _resolver); } else { _o->quantization = std::unique_ptr<tflite::QuantizationParametersT>(_e->UnPack(_resolver)); } } }
13634 { auto _e = is_variable(); _o->is_variable = _e; }
13635 { auto _e = sparsity(); if (_e) { if(_o->sparsity) { _e->UnPackTo(_o->sparsity.get(), _resolver); } else { _o->sparsity = std::unique_ptr<tflite::SparsityParametersT>(_e->UnPack(_resolver)); } } }
13636 { auto _e = shape_signature(); if (_e) { _o->shape_signature.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->shape_signature[_i] = _e->Get(_i); } } }
13637 { auto _e = has_rank(); _o->has_rank = _e; }
13638 { auto _e = variant_tensors(); if (_e) { _o->variant_tensors.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->variant_tensors[_i]) { _e->Get(_i)->UnPackTo(_o->variant_tensors[_i].get(), _resolver); } else { _o->variant_tensors[_i] = std::unique_ptr<tflite::VariantSubTypeT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
13639}
13640
13641inline flatbuffers::Offset<Tensor> Tensor::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13642 return CreateTensor(_fbb, _o, _rehasher);
13643}
13644
13645inline flatbuffers::Offset<Tensor> CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13646 (void)_rehasher;
13647 (void)_o;
13648 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TensorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13649 auto _shape = _o->shape.size() ? _fbb.CreateVector(_o->shape) : 0;
13650 auto _type = _o->type;
13651 auto _buffer = _o->buffer;
13652 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
13653 auto _quantization = _o->quantization ? CreateQuantizationParameters(_fbb, _o->quantization.get(), _rehasher) : 0;
13654 auto _is_variable = _o->is_variable;
13655 auto _sparsity = _o->sparsity ? CreateSparsityParameters(_fbb, _o->sparsity.get(), _rehasher) : 0;
13656 auto _shape_signature = _o->shape_signature.size() ? _fbb.CreateVector(_o->shape_signature) : 0;
13657 auto _has_rank = _o->has_rank;
13658 auto _variant_tensors = _o->variant_tensors.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::VariantSubType>> (_o->variant_tensors.size(), [](size_t i, _VectorArgs *__va) { return CreateVariantSubType(*__va->__fbb, __va->__o->variant_tensors[i].get(), __va->__rehasher); }, &_va ) : 0;
13659 return tflite::CreateTensor(
13660 _fbb,
13661 _shape,
13662 _type,
13663 _buffer,
13664 _name,
13665 _quantization,
13666 _is_variable,
13667 _sparsity,
13668 _shape_signature,
13669 _has_rank,
13670 _variant_tensors);
13671}
13672
13673inline Conv2DOptionsT *Conv2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13674 auto _o = std::unique_ptr<Conv2DOptionsT>(new Conv2DOptionsT());
13675 UnPackTo(_o.get(), _resolver);
13676 return _o.release();
13677}
13678
13679inline void Conv2DOptions::UnPackTo(Conv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13680 (void)_o;
13681 (void)_resolver;
13682 { auto _e = padding(); _o->padding = _e; }
13683 { auto _e = stride_w(); _o->stride_w = _e; }
13684 { auto _e = stride_h(); _o->stride_h = _e; }
13685 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13686 { auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; }
13687 { auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }
13688}
13689
13690inline flatbuffers::Offset<Conv2DOptions> Conv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13691 return CreateConv2DOptions(_fbb, _o, _rehasher);
13692}
13693
13694inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13695 (void)_rehasher;
13696 (void)_o;
13697 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Conv2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13698 auto _padding = _o->padding;
13699 auto _stride_w = _o->stride_w;
13700 auto _stride_h = _o->stride_h;
13701 auto _fused_activation_function = _o->fused_activation_function;
13702 auto _dilation_w_factor = _o->dilation_w_factor;
13703 auto _dilation_h_factor = _o->dilation_h_factor;
13705 _fbb,
13706 _padding,
13707 _stride_w,
13708 _stride_h,
13709 _fused_activation_function,
13710 _dilation_w_factor,
13711 _dilation_h_factor);
13712}
13713
13714inline Conv3DOptionsT *Conv3DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13715 auto _o = std::unique_ptr<Conv3DOptionsT>(new Conv3DOptionsT());
13716 UnPackTo(_o.get(), _resolver);
13717 return _o.release();
13718}
13719
13720inline void Conv3DOptions::UnPackTo(Conv3DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13721 (void)_o;
13722 (void)_resolver;
13723 { auto _e = padding(); _o->padding = _e; }
13724 { auto _e = stride_d(); _o->stride_d = _e; }
13725 { auto _e = stride_w(); _o->stride_w = _e; }
13726 { auto _e = stride_h(); _o->stride_h = _e; }
13727 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13728 { auto _e = dilation_d_factor(); _o->dilation_d_factor = _e; }
13729 { auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; }
13730 { auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }
13731}
13732
13733inline flatbuffers::Offset<Conv3DOptions> Conv3DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13734 return CreateConv3DOptions(_fbb, _o, _rehasher);
13735}
13736
13737inline flatbuffers::Offset<Conv3DOptions> CreateConv3DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13738 (void)_rehasher;
13739 (void)_o;
13740 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Conv3DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13741 auto _padding = _o->padding;
13742 auto _stride_d = _o->stride_d;
13743 auto _stride_w = _o->stride_w;
13744 auto _stride_h = _o->stride_h;
13745 auto _fused_activation_function = _o->fused_activation_function;
13746 auto _dilation_d_factor = _o->dilation_d_factor;
13747 auto _dilation_w_factor = _o->dilation_w_factor;
13748 auto _dilation_h_factor = _o->dilation_h_factor;
13750 _fbb,
13751 _padding,
13752 _stride_d,
13753 _stride_w,
13754 _stride_h,
13755 _fused_activation_function,
13756 _dilation_d_factor,
13757 _dilation_w_factor,
13758 _dilation_h_factor);
13759}
13760
13761inline Pool2DOptionsT *Pool2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13762 auto _o = std::unique_ptr<Pool2DOptionsT>(new Pool2DOptionsT());
13763 UnPackTo(_o.get(), _resolver);
13764 return _o.release();
13765}
13766
13767inline void Pool2DOptions::UnPackTo(Pool2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13768 (void)_o;
13769 (void)_resolver;
13770 { auto _e = padding(); _o->padding = _e; }
13771 { auto _e = stride_w(); _o->stride_w = _e; }
13772 { auto _e = stride_h(); _o->stride_h = _e; }
13773 { auto _e = filter_width(); _o->filter_width = _e; }
13774 { auto _e = filter_height(); _o->filter_height = _e; }
13775 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13776}
13777
13778inline flatbuffers::Offset<Pool2DOptions> Pool2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13779 return CreatePool2DOptions(_fbb, _o, _rehasher);
13780}
13781
13782inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13783 (void)_rehasher;
13784 (void)_o;
13785 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Pool2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13786 auto _padding = _o->padding;
13787 auto _stride_w = _o->stride_w;
13788 auto _stride_h = _o->stride_h;
13789 auto _filter_width = _o->filter_width;
13790 auto _filter_height = _o->filter_height;
13791 auto _fused_activation_function = _o->fused_activation_function;
13793 _fbb,
13794 _padding,
13795 _stride_w,
13796 _stride_h,
13797 _filter_width,
13798 _filter_height,
13799 _fused_activation_function);
13800}
13801
13802inline DepthwiseConv2DOptionsT *DepthwiseConv2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13803 auto _o = std::unique_ptr<DepthwiseConv2DOptionsT>(new DepthwiseConv2DOptionsT());
13804 UnPackTo(_o.get(), _resolver);
13805 return _o.release();
13806}
13807
13808inline void DepthwiseConv2DOptions::UnPackTo(DepthwiseConv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13809 (void)_o;
13810 (void)_resolver;
13811 { auto _e = padding(); _o->padding = _e; }
13812 { auto _e = stride_w(); _o->stride_w = _e; }
13813 { auto _e = stride_h(); _o->stride_h = _e; }
13814 { auto _e = depth_multiplier(); _o->depth_multiplier = _e; }
13815 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13816 { auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; }
13817 { auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }
13818}
13819
13820inline flatbuffers::Offset<DepthwiseConv2DOptions> DepthwiseConv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13821 return CreateDepthwiseConv2DOptions(_fbb, _o, _rehasher);
13822}
13823
13824inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13825 (void)_rehasher;
13826 (void)_o;
13827 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DepthwiseConv2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13828 auto _padding = _o->padding;
13829 auto _stride_w = _o->stride_w;
13830 auto _stride_h = _o->stride_h;
13831 auto _depth_multiplier = _o->depth_multiplier;
13832 auto _fused_activation_function = _o->fused_activation_function;
13833 auto _dilation_w_factor = _o->dilation_w_factor;
13834 auto _dilation_h_factor = _o->dilation_h_factor;
13836 _fbb,
13837 _padding,
13838 _stride_w,
13839 _stride_h,
13840 _depth_multiplier,
13841 _fused_activation_function,
13842 _dilation_w_factor,
13843 _dilation_h_factor);
13844}
13845
13846inline ConcatEmbeddingsOptionsT *ConcatEmbeddingsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13847 auto _o = std::unique_ptr<ConcatEmbeddingsOptionsT>(new ConcatEmbeddingsOptionsT());
13848 UnPackTo(_o.get(), _resolver);
13849 return _o.release();
13850}
13851
13852inline void ConcatEmbeddingsOptions::UnPackTo(ConcatEmbeddingsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13853 (void)_o;
13854 (void)_resolver;
13855 { auto _e = num_channels(); _o->num_channels = _e; }
13856 { auto _e = num_columns_per_channel(); if (_e) { _o->num_columns_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->num_columns_per_channel[_i] = _e->Get(_i); } } }
13857 { auto _e = embedding_dim_per_channel(); if (_e) { _o->embedding_dim_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->embedding_dim_per_channel[_i] = _e->Get(_i); } } }
13858}
13859
13860inline flatbuffers::Offset<ConcatEmbeddingsOptions> ConcatEmbeddingsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13861 return CreateConcatEmbeddingsOptions(_fbb, _o, _rehasher);
13862}
13863
13864inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13865 (void)_rehasher;
13866 (void)_o;
13867 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConcatEmbeddingsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13868 auto _num_channels = _o->num_channels;
13869 auto _num_columns_per_channel = _o->num_columns_per_channel.size() ? _fbb.CreateVector(_o->num_columns_per_channel) : 0;
13870 auto _embedding_dim_per_channel = _o->embedding_dim_per_channel.size() ? _fbb.CreateVector(_o->embedding_dim_per_channel) : 0;
13872 _fbb,
13873 _num_channels,
13874 _num_columns_per_channel,
13875 _embedding_dim_per_channel);
13876}
13877
13878inline LSHProjectionOptionsT *LSHProjectionOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13879 auto _o = std::unique_ptr<LSHProjectionOptionsT>(new LSHProjectionOptionsT());
13880 UnPackTo(_o.get(), _resolver);
13881 return _o.release();
13882}
13883
13884inline void LSHProjectionOptions::UnPackTo(LSHProjectionOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13885 (void)_o;
13886 (void)_resolver;
13887 { auto _e = type(); _o->type = _e; }
13888}
13889
13890inline flatbuffers::Offset<LSHProjectionOptions> LSHProjectionOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13891 return CreateLSHProjectionOptions(_fbb, _o, _rehasher);
13892}
13893
13894inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13895 (void)_rehasher;
13896 (void)_o;
13897 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LSHProjectionOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13898 auto _type = _o->type;
13900 _fbb,
13901 _type);
13902}
13903
13904inline SVDFOptionsT *SVDFOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13905 auto _o = std::unique_ptr<SVDFOptionsT>(new SVDFOptionsT());
13906 UnPackTo(_o.get(), _resolver);
13907 return _o.release();
13908}
13909
13910inline void SVDFOptions::UnPackTo(SVDFOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13911 (void)_o;
13912 (void)_resolver;
13913 { auto _e = rank(); _o->rank = _e; }
13914 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13915 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
13916}
13917
13918inline flatbuffers::Offset<SVDFOptions> SVDFOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13919 return CreateSVDFOptions(_fbb, _o, _rehasher);
13920}
13921
13922inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13923 (void)_rehasher;
13924 (void)_o;
13925 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SVDFOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13926 auto _rank = _o->rank;
13927 auto _fused_activation_function = _o->fused_activation_function;
13928 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
13930 _fbb,
13931 _rank,
13932 _fused_activation_function,
13933 _asymmetric_quantize_inputs);
13934}
13935
13936inline RNNOptionsT *RNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13937 auto _o = std::unique_ptr<RNNOptionsT>(new RNNOptionsT());
13938 UnPackTo(_o.get(), _resolver);
13939 return _o.release();
13940}
13941
13942inline void RNNOptions::UnPackTo(RNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13943 (void)_o;
13944 (void)_resolver;
13945 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13946 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
13947}
13948
13949inline flatbuffers::Offset<RNNOptions> RNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13950 return CreateRNNOptions(_fbb, _o, _rehasher);
13951}
13952
13953inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13954 (void)_rehasher;
13955 (void)_o;
13956 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13957 auto _fused_activation_function = _o->fused_activation_function;
13958 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
13960 _fbb,
13961 _fused_activation_function,
13962 _asymmetric_quantize_inputs);
13963}
13964
13965inline SequenceRNNOptionsT *SequenceRNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13966 auto _o = std::unique_ptr<SequenceRNNOptionsT>(new SequenceRNNOptionsT());
13967 UnPackTo(_o.get(), _resolver);
13968 return _o.release();
13969}
13970
13971inline void SequenceRNNOptions::UnPackTo(SequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
13972 (void)_o;
13973 (void)_resolver;
13974 { auto _e = time_major(); _o->time_major = _e; }
13975 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
13976 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
13977}
13978
13979inline flatbuffers::Offset<SequenceRNNOptions> SequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
13980 return CreateSequenceRNNOptions(_fbb, _o, _rehasher);
13981}
13982
13983inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
13984 (void)_rehasher;
13985 (void)_o;
13986 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SequenceRNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
13987 auto _time_major = _o->time_major;
13988 auto _fused_activation_function = _o->fused_activation_function;
13989 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
13991 _fbb,
13992 _time_major,
13993 _fused_activation_function,
13994 _asymmetric_quantize_inputs);
13995}
13996
13997inline BidirectionalSequenceRNNOptionsT *BidirectionalSequenceRNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
13998 auto _o = std::unique_ptr<BidirectionalSequenceRNNOptionsT>(new BidirectionalSequenceRNNOptionsT());
13999 UnPackTo(_o.get(), _resolver);
14000 return _o.release();
14001}
14002
14003inline void BidirectionalSequenceRNNOptions::UnPackTo(BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14004 (void)_o;
14005 (void)_resolver;
14006 { auto _e = time_major(); _o->time_major = _e; }
14007 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14008 { auto _e = merge_outputs(); _o->merge_outputs = _e; }
14009 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
14010}
14011
14012inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> BidirectionalSequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14013 return CreateBidirectionalSequenceRNNOptions(_fbb, _o, _rehasher);
14014}
14015
14016inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14017 (void)_rehasher;
14018 (void)_o;
14019 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BidirectionalSequenceRNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14020 auto _time_major = _o->time_major;
14021 auto _fused_activation_function = _o->fused_activation_function;
14022 auto _merge_outputs = _o->merge_outputs;
14023 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
14025 _fbb,
14026 _time_major,
14027 _fused_activation_function,
14028 _merge_outputs,
14029 _asymmetric_quantize_inputs);
14030}
14031
14032inline FullyConnectedOptionsT *FullyConnectedOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14033 auto _o = std::unique_ptr<FullyConnectedOptionsT>(new FullyConnectedOptionsT());
14034 UnPackTo(_o.get(), _resolver);
14035 return _o.release();
14036}
14037
14038inline void FullyConnectedOptions::UnPackTo(FullyConnectedOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14039 (void)_o;
14040 (void)_resolver;
14041 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14042 { auto _e = weights_format(); _o->weights_format = _e; }
14043 { auto _e = keep_num_dims(); _o->keep_num_dims = _e; }
14044 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
14045}
14046
14047inline flatbuffers::Offset<FullyConnectedOptions> FullyConnectedOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14048 return CreateFullyConnectedOptions(_fbb, _o, _rehasher);
14049}
14050
14051inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14052 (void)_rehasher;
14053 (void)_o;
14054 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FullyConnectedOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14055 auto _fused_activation_function = _o->fused_activation_function;
14056 auto _weights_format = _o->weights_format;
14057 auto _keep_num_dims = _o->keep_num_dims;
14058 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
14060 _fbb,
14061 _fused_activation_function,
14062 _weights_format,
14063 _keep_num_dims,
14064 _asymmetric_quantize_inputs);
14065}
14066
14067inline SoftmaxOptionsT *SoftmaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14068 auto _o = std::unique_ptr<SoftmaxOptionsT>(new SoftmaxOptionsT());
14069 UnPackTo(_o.get(), _resolver);
14070 return _o.release();
14071}
14072
14073inline void SoftmaxOptions::UnPackTo(SoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14074 (void)_o;
14075 (void)_resolver;
14076 { auto _e = beta(); _o->beta = _e; }
14077}
14078
14079inline flatbuffers::Offset<SoftmaxOptions> SoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14080 return CreateSoftmaxOptions(_fbb, _o, _rehasher);
14081}
14082
14083inline flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14084 (void)_rehasher;
14085 (void)_o;
14086 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SoftmaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14087 auto _beta = _o->beta;
14089 _fbb,
14090 _beta);
14091}
14092
14093inline ConcatenationOptionsT *ConcatenationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14094 auto _o = std::unique_ptr<ConcatenationOptionsT>(new ConcatenationOptionsT());
14095 UnPackTo(_o.get(), _resolver);
14096 return _o.release();
14097}
14098
14099inline void ConcatenationOptions::UnPackTo(ConcatenationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14100 (void)_o;
14101 (void)_resolver;
14102 { auto _e = axis(); _o->axis = _e; }
14103 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14104}
14105
14106inline flatbuffers::Offset<ConcatenationOptions> ConcatenationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14107 return CreateConcatenationOptions(_fbb, _o, _rehasher);
14108}
14109
14110inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14111 (void)_rehasher;
14112 (void)_o;
14113 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConcatenationOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14114 auto _axis = _o->axis;
14115 auto _fused_activation_function = _o->fused_activation_function;
14117 _fbb,
14118 _axis,
14119 _fused_activation_function);
14120}
14121
14122inline AddOptionsT *AddOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14123 auto _o = std::unique_ptr<AddOptionsT>(new AddOptionsT());
14124 UnPackTo(_o.get(), _resolver);
14125 return _o.release();
14126}
14127
14128inline void AddOptions::UnPackTo(AddOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14129 (void)_o;
14130 (void)_resolver;
14131 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14132 { auto _e = pot_scale_int16(); _o->pot_scale_int16 = _e; }
14133}
14134
14135inline flatbuffers::Offset<AddOptions> AddOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14136 return CreateAddOptions(_fbb, _o, _rehasher);
14137}
14138
14139inline flatbuffers::Offset<AddOptions> CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14140 (void)_rehasher;
14141 (void)_o;
14142 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AddOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14143 auto _fused_activation_function = _o->fused_activation_function;
14144 auto _pot_scale_int16 = _o->pot_scale_int16;
14146 _fbb,
14147 _fused_activation_function,
14148 _pot_scale_int16);
14149}
14150
14151inline MulOptionsT *MulOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14152 auto _o = std::unique_ptr<MulOptionsT>(new MulOptionsT());
14153 UnPackTo(_o.get(), _resolver);
14154 return _o.release();
14155}
14156
14157inline void MulOptions::UnPackTo(MulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14158 (void)_o;
14159 (void)_resolver;
14160 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14161}
14162
14163inline flatbuffers::Offset<MulOptions> MulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14164 return CreateMulOptions(_fbb, _o, _rehasher);
14165}
14166
14167inline flatbuffers::Offset<MulOptions> CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14168 (void)_rehasher;
14169 (void)_o;
14170 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MulOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14171 auto _fused_activation_function = _o->fused_activation_function;
14173 _fbb,
14174 _fused_activation_function);
14175}
14176
14177inline L2NormOptionsT *L2NormOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14178 auto _o = std::unique_ptr<L2NormOptionsT>(new L2NormOptionsT());
14179 UnPackTo(_o.get(), _resolver);
14180 return _o.release();
14181}
14182
14183inline void L2NormOptions::UnPackTo(L2NormOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14184 (void)_o;
14185 (void)_resolver;
14186 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14187}
14188
14189inline flatbuffers::Offset<L2NormOptions> L2NormOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14190 return CreateL2NormOptions(_fbb, _o, _rehasher);
14191}
14192
14193inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14194 (void)_rehasher;
14195 (void)_o;
14196 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const L2NormOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14197 auto _fused_activation_function = _o->fused_activation_function;
14199 _fbb,
14200 _fused_activation_function);
14201}
14202
14203inline LocalResponseNormalizationOptionsT *LocalResponseNormalizationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14204 auto _o = std::unique_ptr<LocalResponseNormalizationOptionsT>(new LocalResponseNormalizationOptionsT());
14205 UnPackTo(_o.get(), _resolver);
14206 return _o.release();
14207}
14208
14209inline void LocalResponseNormalizationOptions::UnPackTo(LocalResponseNormalizationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14210 (void)_o;
14211 (void)_resolver;
14212 { auto _e = radius(); _o->radius = _e; }
14213 { auto _e = bias(); _o->bias = _e; }
14214 { auto _e = alpha(); _o->alpha = _e; }
14215 { auto _e = beta(); _o->beta = _e; }
14216}
14217
14218inline flatbuffers::Offset<LocalResponseNormalizationOptions> LocalResponseNormalizationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14219 return CreateLocalResponseNormalizationOptions(_fbb, _o, _rehasher);
14220}
14221
14222inline flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14223 (void)_rehasher;
14224 (void)_o;
14225 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LocalResponseNormalizationOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14226 auto _radius = _o->radius;
14227 auto _bias = _o->bias;
14228 auto _alpha = _o->alpha;
14229 auto _beta = _o->beta;
14231 _fbb,
14232 _radius,
14233 _bias,
14234 _alpha,
14235 _beta);
14236}
14237
14238inline LSTMOptionsT *LSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14239 auto _o = std::unique_ptr<LSTMOptionsT>(new LSTMOptionsT());
14240 UnPackTo(_o.get(), _resolver);
14241 return _o.release();
14242}
14243
14244inline void LSTMOptions::UnPackTo(LSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14245 (void)_o;
14246 (void)_resolver;
14247 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14248 { auto _e = cell_clip(); _o->cell_clip = _e; }
14249 { auto _e = proj_clip(); _o->proj_clip = _e; }
14250 { auto _e = kernel_type(); _o->kernel_type = _e; }
14251 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
14252}
14253
14254inline flatbuffers::Offset<LSTMOptions> LSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14255 return CreateLSTMOptions(_fbb, _o, _rehasher);
14256}
14257
14258inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14259 (void)_rehasher;
14260 (void)_o;
14261 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14262 auto _fused_activation_function = _o->fused_activation_function;
14263 auto _cell_clip = _o->cell_clip;
14264 auto _proj_clip = _o->proj_clip;
14265 auto _kernel_type = _o->kernel_type;
14266 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
14268 _fbb,
14269 _fused_activation_function,
14270 _cell_clip,
14271 _proj_clip,
14272 _kernel_type,
14273 _asymmetric_quantize_inputs);
14274}
14275
14276inline UnidirectionalSequenceLSTMOptionsT *UnidirectionalSequenceLSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14277 auto _o = std::unique_ptr<UnidirectionalSequenceLSTMOptionsT>(new UnidirectionalSequenceLSTMOptionsT());
14278 UnPackTo(_o.get(), _resolver);
14279 return _o.release();
14280}
14281
14282inline void UnidirectionalSequenceLSTMOptions::UnPackTo(UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14283 (void)_o;
14284 (void)_resolver;
14285 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14286 { auto _e = cell_clip(); _o->cell_clip = _e; }
14287 { auto _e = proj_clip(); _o->proj_clip = _e; }
14288 { auto _e = time_major(); _o->time_major = _e; }
14289 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
14290 { auto _e = diagonal_recurrent_tensors(); _o->diagonal_recurrent_tensors = _e; }
14291}
14292
14293inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> UnidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14294 return CreateUnidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher);
14295}
14296
14297inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14298 (void)_rehasher;
14299 (void)_o;
14300 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnidirectionalSequenceLSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14301 auto _fused_activation_function = _o->fused_activation_function;
14302 auto _cell_clip = _o->cell_clip;
14303 auto _proj_clip = _o->proj_clip;
14304 auto _time_major = _o->time_major;
14305 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
14306 auto _diagonal_recurrent_tensors = _o->diagonal_recurrent_tensors;
14308 _fbb,
14309 _fused_activation_function,
14310 _cell_clip,
14311 _proj_clip,
14312 _time_major,
14313 _asymmetric_quantize_inputs,
14314 _diagonal_recurrent_tensors);
14315}
14316
14317inline BidirectionalSequenceLSTMOptionsT *BidirectionalSequenceLSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14318 auto _o = std::unique_ptr<BidirectionalSequenceLSTMOptionsT>(new BidirectionalSequenceLSTMOptionsT());
14319 UnPackTo(_o.get(), _resolver);
14320 return _o.release();
14321}
14322
14323inline void BidirectionalSequenceLSTMOptions::UnPackTo(BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14324 (void)_o;
14325 (void)_resolver;
14326 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14327 { auto _e = cell_clip(); _o->cell_clip = _e; }
14328 { auto _e = proj_clip(); _o->proj_clip = _e; }
14329 { auto _e = merge_outputs(); _o->merge_outputs = _e; }
14330 { auto _e = time_major(); _o->time_major = _e; }
14331 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
14332}
14333
14334inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> BidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14335 return CreateBidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher);
14336}
14337
14338inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14339 (void)_rehasher;
14340 (void)_o;
14341 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BidirectionalSequenceLSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14342 auto _fused_activation_function = _o->fused_activation_function;
14343 auto _cell_clip = _o->cell_clip;
14344 auto _proj_clip = _o->proj_clip;
14345 auto _merge_outputs = _o->merge_outputs;
14346 auto _time_major = _o->time_major;
14347 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
14349 _fbb,
14350 _fused_activation_function,
14351 _cell_clip,
14352 _proj_clip,
14353 _merge_outputs,
14354 _time_major,
14355 _asymmetric_quantize_inputs);
14356}
14357
14358inline ResizeBilinearOptionsT *ResizeBilinearOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14359 auto _o = std::unique_ptr<ResizeBilinearOptionsT>(new ResizeBilinearOptionsT());
14360 UnPackTo(_o.get(), _resolver);
14361 return _o.release();
14362}
14363
14364inline void ResizeBilinearOptions::UnPackTo(ResizeBilinearOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14365 (void)_o;
14366 (void)_resolver;
14367 { auto _e = align_corners(); _o->align_corners = _e; }
14368 { auto _e = half_pixel_centers(); _o->half_pixel_centers = _e; }
14369}
14370
14371inline flatbuffers::Offset<ResizeBilinearOptions> ResizeBilinearOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14372 return CreateResizeBilinearOptions(_fbb, _o, _rehasher);
14373}
14374
14375inline flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14376 (void)_rehasher;
14377 (void)_o;
14378 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ResizeBilinearOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14379 auto _align_corners = _o->align_corners;
14380 auto _half_pixel_centers = _o->half_pixel_centers;
14382 _fbb,
14383 _align_corners,
14384 _half_pixel_centers);
14385}
14386
14387inline ResizeNearestNeighborOptionsT *ResizeNearestNeighborOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14388 auto _o = std::unique_ptr<ResizeNearestNeighborOptionsT>(new ResizeNearestNeighborOptionsT());
14389 UnPackTo(_o.get(), _resolver);
14390 return _o.release();
14391}
14392
14393inline void ResizeNearestNeighborOptions::UnPackTo(ResizeNearestNeighborOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14394 (void)_o;
14395 (void)_resolver;
14396 { auto _e = align_corners(); _o->align_corners = _e; }
14397 { auto _e = half_pixel_centers(); _o->half_pixel_centers = _e; }
14398}
14399
14400inline flatbuffers::Offset<ResizeNearestNeighborOptions> ResizeNearestNeighborOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14401 return CreateResizeNearestNeighborOptions(_fbb, _o, _rehasher);
14402}
14403
14404inline flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14405 (void)_rehasher;
14406 (void)_o;
14407 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ResizeNearestNeighborOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14408 auto _align_corners = _o->align_corners;
14409 auto _half_pixel_centers = _o->half_pixel_centers;
14411 _fbb,
14412 _align_corners,
14413 _half_pixel_centers);
14414}
14415
14416inline CallOptionsT *CallOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14417 auto _o = std::unique_ptr<CallOptionsT>(new CallOptionsT());
14418 UnPackTo(_o.get(), _resolver);
14419 return _o.release();
14420}
14421
14422inline void CallOptions::UnPackTo(CallOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14423 (void)_o;
14424 (void)_resolver;
14425 { auto _e = subgraph(); _o->subgraph = _e; }
14426}
14427
14428inline flatbuffers::Offset<CallOptions> CallOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14429 return CreateCallOptions(_fbb, _o, _rehasher);
14430}
14431
14432inline flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14433 (void)_rehasher;
14434 (void)_o;
14435 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CallOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14436 auto _subgraph = _o->subgraph;
14438 _fbb,
14439 _subgraph);
14440}
14441
14442inline PadOptionsT *PadOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14443 auto _o = std::unique_ptr<PadOptionsT>(new PadOptionsT());
14444 UnPackTo(_o.get(), _resolver);
14445 return _o.release();
14446}
14447
14448inline void PadOptions::UnPackTo(PadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14449 (void)_o;
14450 (void)_resolver;
14451}
14452
14453inline flatbuffers::Offset<PadOptions> PadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14454 return CreatePadOptions(_fbb, _o, _rehasher);
14455}
14456
14457inline flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14458 (void)_rehasher;
14459 (void)_o;
14460 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PadOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14462 _fbb);
14463}
14464
14465inline PadV2OptionsT *PadV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14466 auto _o = std::unique_ptr<PadV2OptionsT>(new PadV2OptionsT());
14467 UnPackTo(_o.get(), _resolver);
14468 return _o.release();
14469}
14470
14471inline void PadV2Options::UnPackTo(PadV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14472 (void)_o;
14473 (void)_resolver;
14474}
14475
14476inline flatbuffers::Offset<PadV2Options> PadV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14477 return CreatePadV2Options(_fbb, _o, _rehasher);
14478}
14479
14480inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14481 (void)_rehasher;
14482 (void)_o;
14483 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PadV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14485 _fbb);
14486}
14487
14488inline ReshapeOptionsT *ReshapeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14489 auto _o = std::unique_ptr<ReshapeOptionsT>(new ReshapeOptionsT());
14490 UnPackTo(_o.get(), _resolver);
14491 return _o.release();
14492}
14493
14494inline void ReshapeOptions::UnPackTo(ReshapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14495 (void)_o;
14496 (void)_resolver;
14497 { auto _e = new_shape(); if (_e) { _o->new_shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->new_shape[_i] = _e->Get(_i); } } }
14498}
14499
14500inline flatbuffers::Offset<ReshapeOptions> ReshapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14501 return CreateReshapeOptions(_fbb, _o, _rehasher);
14502}
14503
14504inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14505 (void)_rehasher;
14506 (void)_o;
14507 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReshapeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14508 auto _new_shape = _o->new_shape.size() ? _fbb.CreateVector(_o->new_shape) : 0;
14510 _fbb,
14511 _new_shape);
14512}
14513
14514inline SpaceToBatchNDOptionsT *SpaceToBatchNDOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14515 auto _o = std::unique_ptr<SpaceToBatchNDOptionsT>(new SpaceToBatchNDOptionsT());
14516 UnPackTo(_o.get(), _resolver);
14517 return _o.release();
14518}
14519
14520inline void SpaceToBatchNDOptions::UnPackTo(SpaceToBatchNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14521 (void)_o;
14522 (void)_resolver;
14523}
14524
14525inline flatbuffers::Offset<SpaceToBatchNDOptions> SpaceToBatchNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14526 return CreateSpaceToBatchNDOptions(_fbb, _o, _rehasher);
14527}
14528
14529inline flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14530 (void)_rehasher;
14531 (void)_o;
14532 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SpaceToBatchNDOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14534 _fbb);
14535}
14536
14537inline BatchToSpaceNDOptionsT *BatchToSpaceNDOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14538 auto _o = std::unique_ptr<BatchToSpaceNDOptionsT>(new BatchToSpaceNDOptionsT());
14539 UnPackTo(_o.get(), _resolver);
14540 return _o.release();
14541}
14542
14543inline void BatchToSpaceNDOptions::UnPackTo(BatchToSpaceNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14544 (void)_o;
14545 (void)_resolver;
14546}
14547
14548inline flatbuffers::Offset<BatchToSpaceNDOptions> BatchToSpaceNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14549 return CreateBatchToSpaceNDOptions(_fbb, _o, _rehasher);
14550}
14551
14552inline flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14553 (void)_rehasher;
14554 (void)_o;
14555 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BatchToSpaceNDOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14557 _fbb);
14558}
14559
14560inline SkipGramOptionsT *SkipGramOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14561 auto _o = std::unique_ptr<SkipGramOptionsT>(new SkipGramOptionsT());
14562 UnPackTo(_o.get(), _resolver);
14563 return _o.release();
14564}
14565
14566inline void SkipGramOptions::UnPackTo(SkipGramOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14567 (void)_o;
14568 (void)_resolver;
14569 { auto _e = ngram_size(); _o->ngram_size = _e; }
14570 { auto _e = max_skip_size(); _o->max_skip_size = _e; }
14571 { auto _e = include_all_ngrams(); _o->include_all_ngrams = _e; }
14572}
14573
14574inline flatbuffers::Offset<SkipGramOptions> SkipGramOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14575 return CreateSkipGramOptions(_fbb, _o, _rehasher);
14576}
14577
14578inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14579 (void)_rehasher;
14580 (void)_o;
14581 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SkipGramOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14582 auto _ngram_size = _o->ngram_size;
14583 auto _max_skip_size = _o->max_skip_size;
14584 auto _include_all_ngrams = _o->include_all_ngrams;
14586 _fbb,
14587 _ngram_size,
14588 _max_skip_size,
14589 _include_all_ngrams);
14590}
14591
14592inline SpaceToDepthOptionsT *SpaceToDepthOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14593 auto _o = std::unique_ptr<SpaceToDepthOptionsT>(new SpaceToDepthOptionsT());
14594 UnPackTo(_o.get(), _resolver);
14595 return _o.release();
14596}
14597
14598inline void SpaceToDepthOptions::UnPackTo(SpaceToDepthOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14599 (void)_o;
14600 (void)_resolver;
14601 { auto _e = block_size(); _o->block_size = _e; }
14602}
14603
14604inline flatbuffers::Offset<SpaceToDepthOptions> SpaceToDepthOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14605 return CreateSpaceToDepthOptions(_fbb, _o, _rehasher);
14606}
14607
14608inline flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14609 (void)_rehasher;
14610 (void)_o;
14611 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SpaceToDepthOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14612 auto _block_size = _o->block_size;
14614 _fbb,
14615 _block_size);
14616}
14617
14618inline DepthToSpaceOptionsT *DepthToSpaceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14619 auto _o = std::unique_ptr<DepthToSpaceOptionsT>(new DepthToSpaceOptionsT());
14620 UnPackTo(_o.get(), _resolver);
14621 return _o.release();
14622}
14623
14624inline void DepthToSpaceOptions::UnPackTo(DepthToSpaceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14625 (void)_o;
14626 (void)_resolver;
14627 { auto _e = block_size(); _o->block_size = _e; }
14628}
14629
14630inline flatbuffers::Offset<DepthToSpaceOptions> DepthToSpaceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14631 return CreateDepthToSpaceOptions(_fbb, _o, _rehasher);
14632}
14633
14634inline flatbuffers::Offset<DepthToSpaceOptions> CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14635 (void)_rehasher;
14636 (void)_o;
14637 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DepthToSpaceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14638 auto _block_size = _o->block_size;
14640 _fbb,
14641 _block_size);
14642}
14643
14644inline SubOptionsT *SubOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14645 auto _o = std::unique_ptr<SubOptionsT>(new SubOptionsT());
14646 UnPackTo(_o.get(), _resolver);
14647 return _o.release();
14648}
14649
14650inline void SubOptions::UnPackTo(SubOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14651 (void)_o;
14652 (void)_resolver;
14653 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14654 { auto _e = pot_scale_int16(); _o->pot_scale_int16 = _e; }
14655}
14656
14657inline flatbuffers::Offset<SubOptions> SubOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14658 return CreateSubOptions(_fbb, _o, _rehasher);
14659}
14660
14661inline flatbuffers::Offset<SubOptions> CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14662 (void)_rehasher;
14663 (void)_o;
14664 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SubOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14665 auto _fused_activation_function = _o->fused_activation_function;
14666 auto _pot_scale_int16 = _o->pot_scale_int16;
14668 _fbb,
14669 _fused_activation_function,
14670 _pot_scale_int16);
14671}
14672
14673inline DivOptionsT *DivOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14674 auto _o = std::unique_ptr<DivOptionsT>(new DivOptionsT());
14675 UnPackTo(_o.get(), _resolver);
14676 return _o.release();
14677}
14678
14679inline void DivOptions::UnPackTo(DivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14680 (void)_o;
14681 (void)_resolver;
14682 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
14683}
14684
14685inline flatbuffers::Offset<DivOptions> DivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14686 return CreateDivOptions(_fbb, _o, _rehasher);
14687}
14688
14689inline flatbuffers::Offset<DivOptions> CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14690 (void)_rehasher;
14691 (void)_o;
14692 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DivOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14693 auto _fused_activation_function = _o->fused_activation_function;
14695 _fbb,
14696 _fused_activation_function);
14697}
14698
14699inline TopKV2OptionsT *TopKV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14700 auto _o = std::unique_ptr<TopKV2OptionsT>(new TopKV2OptionsT());
14701 UnPackTo(_o.get(), _resolver);
14702 return _o.release();
14703}
14704
14705inline void TopKV2Options::UnPackTo(TopKV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14706 (void)_o;
14707 (void)_resolver;
14708}
14709
14710inline flatbuffers::Offset<TopKV2Options> TopKV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14711 return CreateTopKV2Options(_fbb, _o, _rehasher);
14712}
14713
14714inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14715 (void)_rehasher;
14716 (void)_o;
14717 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TopKV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14719 _fbb);
14720}
14721
14722inline EmbeddingLookupSparseOptionsT *EmbeddingLookupSparseOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14723 auto _o = std::unique_ptr<EmbeddingLookupSparseOptionsT>(new EmbeddingLookupSparseOptionsT());
14724 UnPackTo(_o.get(), _resolver);
14725 return _o.release();
14726}
14727
14728inline void EmbeddingLookupSparseOptions::UnPackTo(EmbeddingLookupSparseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14729 (void)_o;
14730 (void)_resolver;
14731 { auto _e = combiner(); _o->combiner = _e; }
14732}
14733
14734inline flatbuffers::Offset<EmbeddingLookupSparseOptions> EmbeddingLookupSparseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14735 return CreateEmbeddingLookupSparseOptions(_fbb, _o, _rehasher);
14736}
14737
14738inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14739 (void)_rehasher;
14740 (void)_o;
14741 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EmbeddingLookupSparseOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14742 auto _combiner = _o->combiner;
14744 _fbb,
14745 _combiner);
14746}
14747
14748inline GatherOptionsT *GatherOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14749 auto _o = std::unique_ptr<GatherOptionsT>(new GatherOptionsT());
14750 UnPackTo(_o.get(), _resolver);
14751 return _o.release();
14752}
14753
14754inline void GatherOptions::UnPackTo(GatherOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14755 (void)_o;
14756 (void)_resolver;
14757 { auto _e = axis(); _o->axis = _e; }
14758 { auto _e = batch_dims(); _o->batch_dims = _e; }
14759}
14760
14761inline flatbuffers::Offset<GatherOptions> GatherOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14762 return CreateGatherOptions(_fbb, _o, _rehasher);
14763}
14764
14765inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14766 (void)_rehasher;
14767 (void)_o;
14768 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GatherOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14769 auto _axis = _o->axis;
14770 auto _batch_dims = _o->batch_dims;
14772 _fbb,
14773 _axis,
14774 _batch_dims);
14775}
14776
14777inline TransposeOptionsT *TransposeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14778 auto _o = std::unique_ptr<TransposeOptionsT>(new TransposeOptionsT());
14779 UnPackTo(_o.get(), _resolver);
14780 return _o.release();
14781}
14782
14783inline void TransposeOptions::UnPackTo(TransposeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14784 (void)_o;
14785 (void)_resolver;
14786}
14787
14788inline flatbuffers::Offset<TransposeOptions> TransposeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14789 return CreateTransposeOptions(_fbb, _o, _rehasher);
14790}
14791
14792inline flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14793 (void)_rehasher;
14794 (void)_o;
14795 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TransposeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14797 _fbb);
14798}
14799
14800inline ExpOptionsT *ExpOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14801 auto _o = std::unique_ptr<ExpOptionsT>(new ExpOptionsT());
14802 UnPackTo(_o.get(), _resolver);
14803 return _o.release();
14804}
14805
14806inline void ExpOptions::UnPackTo(ExpOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14807 (void)_o;
14808 (void)_resolver;
14809}
14810
14811inline flatbuffers::Offset<ExpOptions> ExpOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14812 return CreateExpOptions(_fbb, _o, _rehasher);
14813}
14814
14815inline flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14816 (void)_rehasher;
14817 (void)_o;
14818 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExpOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14820 _fbb);
14821}
14822
14823inline CosOptionsT *CosOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14824 auto _o = std::unique_ptr<CosOptionsT>(new CosOptionsT());
14825 UnPackTo(_o.get(), _resolver);
14826 return _o.release();
14827}
14828
14829inline void CosOptions::UnPackTo(CosOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14830 (void)_o;
14831 (void)_resolver;
14832}
14833
14834inline flatbuffers::Offset<CosOptions> CosOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14835 return CreateCosOptions(_fbb, _o, _rehasher);
14836}
14837
14838inline flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14839 (void)_rehasher;
14840 (void)_o;
14841 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CosOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14843 _fbb);
14844}
14845
14846inline ReducerOptionsT *ReducerOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14847 auto _o = std::unique_ptr<ReducerOptionsT>(new ReducerOptionsT());
14848 UnPackTo(_o.get(), _resolver);
14849 return _o.release();
14850}
14851
14852inline void ReducerOptions::UnPackTo(ReducerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14853 (void)_o;
14854 (void)_resolver;
14855 { auto _e = keep_dims(); _o->keep_dims = _e; }
14856}
14857
14858inline flatbuffers::Offset<ReducerOptions> ReducerOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14859 return CreateReducerOptions(_fbb, _o, _rehasher);
14860}
14861
14862inline flatbuffers::Offset<ReducerOptions> CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14863 (void)_rehasher;
14864 (void)_o;
14865 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReducerOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14866 auto _keep_dims = _o->keep_dims;
14868 _fbb,
14869 _keep_dims);
14870}
14871
14872inline SqueezeOptionsT *SqueezeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14873 auto _o = std::unique_ptr<SqueezeOptionsT>(new SqueezeOptionsT());
14874 UnPackTo(_o.get(), _resolver);
14875 return _o.release();
14876}
14877
14878inline void SqueezeOptions::UnPackTo(SqueezeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14879 (void)_o;
14880 (void)_resolver;
14881 { auto _e = squeeze_dims(); if (_e) { _o->squeeze_dims.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->squeeze_dims[_i] = _e->Get(_i); } } }
14882}
14883
14884inline flatbuffers::Offset<SqueezeOptions> SqueezeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14885 return CreateSqueezeOptions(_fbb, _o, _rehasher);
14886}
14887
14888inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14889 (void)_rehasher;
14890 (void)_o;
14891 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SqueezeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14892 auto _squeeze_dims = _o->squeeze_dims.size() ? _fbb.CreateVector(_o->squeeze_dims) : 0;
14894 _fbb,
14895 _squeeze_dims);
14896}
14897
14898inline SplitOptionsT *SplitOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14899 auto _o = std::unique_ptr<SplitOptionsT>(new SplitOptionsT());
14900 UnPackTo(_o.get(), _resolver);
14901 return _o.release();
14902}
14903
14904inline void SplitOptions::UnPackTo(SplitOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14905 (void)_o;
14906 (void)_resolver;
14907 { auto _e = num_splits(); _o->num_splits = _e; }
14908}
14909
14910inline flatbuffers::Offset<SplitOptions> SplitOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14911 return CreateSplitOptions(_fbb, _o, _rehasher);
14912}
14913
14914inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14915 (void)_rehasher;
14916 (void)_o;
14917 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SplitOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14918 auto _num_splits = _o->num_splits;
14920 _fbb,
14921 _num_splits);
14922}
14923
14924inline SplitVOptionsT *SplitVOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14925 auto _o = std::unique_ptr<SplitVOptionsT>(new SplitVOptionsT());
14926 UnPackTo(_o.get(), _resolver);
14927 return _o.release();
14928}
14929
14930inline void SplitVOptions::UnPackTo(SplitVOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14931 (void)_o;
14932 (void)_resolver;
14933 { auto _e = num_splits(); _o->num_splits = _e; }
14934}
14935
14936inline flatbuffers::Offset<SplitVOptions> SplitVOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14937 return CreateSplitVOptions(_fbb, _o, _rehasher);
14938}
14939
14940inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14941 (void)_rehasher;
14942 (void)_o;
14943 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SplitVOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14944 auto _num_splits = _o->num_splits;
14946 _fbb,
14947 _num_splits);
14948}
14949
14950inline StridedSliceOptionsT *StridedSliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14951 auto _o = std::unique_ptr<StridedSliceOptionsT>(new StridedSliceOptionsT());
14952 UnPackTo(_o.get(), _resolver);
14953 return _o.release();
14954}
14955
14956inline void StridedSliceOptions::UnPackTo(StridedSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14957 (void)_o;
14958 (void)_resolver;
14959 { auto _e = begin_mask(); _o->begin_mask = _e; }
14960 { auto _e = end_mask(); _o->end_mask = _e; }
14961 { auto _e = ellipsis_mask(); _o->ellipsis_mask = _e; }
14962 { auto _e = new_axis_mask(); _o->new_axis_mask = _e; }
14963 { auto _e = shrink_axis_mask(); _o->shrink_axis_mask = _e; }
14964}
14965
14966inline flatbuffers::Offset<StridedSliceOptions> StridedSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
14967 return CreateStridedSliceOptions(_fbb, _o, _rehasher);
14968}
14969
14970inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
14971 (void)_rehasher;
14972 (void)_o;
14973 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StridedSliceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
14974 auto _begin_mask = _o->begin_mask;
14975 auto _end_mask = _o->end_mask;
14976 auto _ellipsis_mask = _o->ellipsis_mask;
14977 auto _new_axis_mask = _o->new_axis_mask;
14978 auto _shrink_axis_mask = _o->shrink_axis_mask;
14980 _fbb,
14981 _begin_mask,
14982 _end_mask,
14983 _ellipsis_mask,
14984 _new_axis_mask,
14985 _shrink_axis_mask);
14986}
14987
14988inline LogSoftmaxOptionsT *LogSoftmaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
14989 auto _o = std::unique_ptr<LogSoftmaxOptionsT>(new LogSoftmaxOptionsT());
14990 UnPackTo(_o.get(), _resolver);
14991 return _o.release();
14992}
14993
14994inline void LogSoftmaxOptions::UnPackTo(LogSoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
14995 (void)_o;
14996 (void)_resolver;
14997}
14998
14999inline flatbuffers::Offset<LogSoftmaxOptions> LogSoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15000 return CreateLogSoftmaxOptions(_fbb, _o, _rehasher);
15001}
15002
15003inline flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15004 (void)_rehasher;
15005 (void)_o;
15006 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogSoftmaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15008 _fbb);
15009}
15010
15011inline CastOptionsT *CastOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15012 auto _o = std::unique_ptr<CastOptionsT>(new CastOptionsT());
15013 UnPackTo(_o.get(), _resolver);
15014 return _o.release();
15015}
15016
15017inline void CastOptions::UnPackTo(CastOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15018 (void)_o;
15019 (void)_resolver;
15020 { auto _e = in_data_type(); _o->in_data_type = _e; }
15021 { auto _e = out_data_type(); _o->out_data_type = _e; }
15022}
15023
15024inline flatbuffers::Offset<CastOptions> CastOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15025 return CreateCastOptions(_fbb, _o, _rehasher);
15026}
15027
15028inline flatbuffers::Offset<CastOptions> CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15029 (void)_rehasher;
15030 (void)_o;
15031 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CastOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15032 auto _in_data_type = _o->in_data_type;
15033 auto _out_data_type = _o->out_data_type;
15035 _fbb,
15036 _in_data_type,
15037 _out_data_type);
15038}
15039
15040inline DequantizeOptionsT *DequantizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15041 auto _o = std::unique_ptr<DequantizeOptionsT>(new DequantizeOptionsT());
15042 UnPackTo(_o.get(), _resolver);
15043 return _o.release();
15044}
15045
15046inline void DequantizeOptions::UnPackTo(DequantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15047 (void)_o;
15048 (void)_resolver;
15049}
15050
15051inline flatbuffers::Offset<DequantizeOptions> DequantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15052 return CreateDequantizeOptions(_fbb, _o, _rehasher);
15053}
15054
15055inline flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15056 (void)_rehasher;
15057 (void)_o;
15058 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DequantizeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15060 _fbb);
15061}
15062
15063inline MaximumMinimumOptionsT *MaximumMinimumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15064 auto _o = std::unique_ptr<MaximumMinimumOptionsT>(new MaximumMinimumOptionsT());
15065 UnPackTo(_o.get(), _resolver);
15066 return _o.release();
15067}
15068
15069inline void MaximumMinimumOptions::UnPackTo(MaximumMinimumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15070 (void)_o;
15071 (void)_resolver;
15072}
15073
15074inline flatbuffers::Offset<MaximumMinimumOptions> MaximumMinimumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15075 return CreateMaximumMinimumOptions(_fbb, _o, _rehasher);
15076}
15077
15078inline flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15079 (void)_rehasher;
15080 (void)_o;
15081 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MaximumMinimumOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15083 _fbb);
15084}
15085
15086inline TileOptionsT *TileOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15087 auto _o = std::unique_ptr<TileOptionsT>(new TileOptionsT());
15088 UnPackTo(_o.get(), _resolver);
15089 return _o.release();
15090}
15091
15092inline void TileOptions::UnPackTo(TileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15093 (void)_o;
15094 (void)_resolver;
15095}
15096
15097inline flatbuffers::Offset<TileOptions> TileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15098 return CreateTileOptions(_fbb, _o, _rehasher);
15099}
15100
15101inline flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15102 (void)_rehasher;
15103 (void)_o;
15104 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TileOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15106 _fbb);
15107}
15108
15109inline ArgMaxOptionsT *ArgMaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15110 auto _o = std::unique_ptr<ArgMaxOptionsT>(new ArgMaxOptionsT());
15111 UnPackTo(_o.get(), _resolver);
15112 return _o.release();
15113}
15114
15115inline void ArgMaxOptions::UnPackTo(ArgMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15116 (void)_o;
15117 (void)_resolver;
15118 { auto _e = output_type(); _o->output_type = _e; }
15119}
15120
15121inline flatbuffers::Offset<ArgMaxOptions> ArgMaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15122 return CreateArgMaxOptions(_fbb, _o, _rehasher);
15123}
15124
15125inline flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15126 (void)_rehasher;
15127 (void)_o;
15128 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ArgMaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15129 auto _output_type = _o->output_type;
15131 _fbb,
15132 _output_type);
15133}
15134
15135inline ArgMinOptionsT *ArgMinOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15136 auto _o = std::unique_ptr<ArgMinOptionsT>(new ArgMinOptionsT());
15137 UnPackTo(_o.get(), _resolver);
15138 return _o.release();
15139}
15140
15141inline void ArgMinOptions::UnPackTo(ArgMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15142 (void)_o;
15143 (void)_resolver;
15144 { auto _e = output_type(); _o->output_type = _e; }
15145}
15146
15147inline flatbuffers::Offset<ArgMinOptions> ArgMinOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15148 return CreateArgMinOptions(_fbb, _o, _rehasher);
15149}
15150
15151inline flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15152 (void)_rehasher;
15153 (void)_o;
15154 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ArgMinOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15155 auto _output_type = _o->output_type;
15157 _fbb,
15158 _output_type);
15159}
15160
15161inline GreaterOptionsT *GreaterOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15162 auto _o = std::unique_ptr<GreaterOptionsT>(new GreaterOptionsT());
15163 UnPackTo(_o.get(), _resolver);
15164 return _o.release();
15165}
15166
15167inline void GreaterOptions::UnPackTo(GreaterOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15168 (void)_o;
15169 (void)_resolver;
15170}
15171
15172inline flatbuffers::Offset<GreaterOptions> GreaterOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15173 return CreateGreaterOptions(_fbb, _o, _rehasher);
15174}
15175
15176inline flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15177 (void)_rehasher;
15178 (void)_o;
15179 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GreaterOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15181 _fbb);
15182}
15183
15184inline GreaterEqualOptionsT *GreaterEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15185 auto _o = std::unique_ptr<GreaterEqualOptionsT>(new GreaterEqualOptionsT());
15186 UnPackTo(_o.get(), _resolver);
15187 return _o.release();
15188}
15189
15190inline void GreaterEqualOptions::UnPackTo(GreaterEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15191 (void)_o;
15192 (void)_resolver;
15193}
15194
15195inline flatbuffers::Offset<GreaterEqualOptions> GreaterEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15196 return CreateGreaterEqualOptions(_fbb, _o, _rehasher);
15197}
15198
15199inline flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15200 (void)_rehasher;
15201 (void)_o;
15202 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GreaterEqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15204 _fbb);
15205}
15206
15207inline LessOptionsT *LessOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15208 auto _o = std::unique_ptr<LessOptionsT>(new LessOptionsT());
15209 UnPackTo(_o.get(), _resolver);
15210 return _o.release();
15211}
15212
15213inline void LessOptions::UnPackTo(LessOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15214 (void)_o;
15215 (void)_resolver;
15216}
15217
15218inline flatbuffers::Offset<LessOptions> LessOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15219 return CreateLessOptions(_fbb, _o, _rehasher);
15220}
15221
15222inline flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15223 (void)_rehasher;
15224 (void)_o;
15225 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LessOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15227 _fbb);
15228}
15229
15230inline LessEqualOptionsT *LessEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15231 auto _o = std::unique_ptr<LessEqualOptionsT>(new LessEqualOptionsT());
15232 UnPackTo(_o.get(), _resolver);
15233 return _o.release();
15234}
15235
15236inline void LessEqualOptions::UnPackTo(LessEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15237 (void)_o;
15238 (void)_resolver;
15239}
15240
15241inline flatbuffers::Offset<LessEqualOptions> LessEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15242 return CreateLessEqualOptions(_fbb, _o, _rehasher);
15243}
15244
15245inline flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15246 (void)_rehasher;
15247 (void)_o;
15248 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LessEqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15250 _fbb);
15251}
15252
15253inline NegOptionsT *NegOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15254 auto _o = std::unique_ptr<NegOptionsT>(new NegOptionsT());
15255 UnPackTo(_o.get(), _resolver);
15256 return _o.release();
15257}
15258
15259inline void NegOptions::UnPackTo(NegOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15260 (void)_o;
15261 (void)_resolver;
15262}
15263
15264inline flatbuffers::Offset<NegOptions> NegOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15265 return CreateNegOptions(_fbb, _o, _rehasher);
15266}
15267
15268inline flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15269 (void)_rehasher;
15270 (void)_o;
15271 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NegOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15273 _fbb);
15274}
15275
15276inline SelectOptionsT *SelectOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15277 auto _o = std::unique_ptr<SelectOptionsT>(new SelectOptionsT());
15278 UnPackTo(_o.get(), _resolver);
15279 return _o.release();
15280}
15281
15282inline void SelectOptions::UnPackTo(SelectOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15283 (void)_o;
15284 (void)_resolver;
15285}
15286
15287inline flatbuffers::Offset<SelectOptions> SelectOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15288 return CreateSelectOptions(_fbb, _o, _rehasher);
15289}
15290
15291inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15292 (void)_rehasher;
15293 (void)_o;
15294 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SelectOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15296 _fbb);
15297}
15298
15299inline SliceOptionsT *SliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15300 auto _o = std::unique_ptr<SliceOptionsT>(new SliceOptionsT());
15301 UnPackTo(_o.get(), _resolver);
15302 return _o.release();
15303}
15304
15305inline void SliceOptions::UnPackTo(SliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15306 (void)_o;
15307 (void)_resolver;
15308}
15309
15310inline flatbuffers::Offset<SliceOptions> SliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15311 return CreateSliceOptions(_fbb, _o, _rehasher);
15312}
15313
15314inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15315 (void)_rehasher;
15316 (void)_o;
15317 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SliceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15319 _fbb);
15320}
15321
15322inline TransposeConvOptionsT *TransposeConvOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15323 auto _o = std::unique_ptr<TransposeConvOptionsT>(new TransposeConvOptionsT());
15324 UnPackTo(_o.get(), _resolver);
15325 return _o.release();
15326}
15327
15328inline void TransposeConvOptions::UnPackTo(TransposeConvOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15329 (void)_o;
15330 (void)_resolver;
15331 { auto _e = padding(); _o->padding = _e; }
15332 { auto _e = stride_w(); _o->stride_w = _e; }
15333 { auto _e = stride_h(); _o->stride_h = _e; }
15334 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }
15335}
15336
15337inline flatbuffers::Offset<TransposeConvOptions> TransposeConvOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15338 return CreateTransposeConvOptions(_fbb, _o, _rehasher);
15339}
15340
15341inline flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15342 (void)_rehasher;
15343 (void)_o;
15344 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TransposeConvOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15345 auto _padding = _o->padding;
15346 auto _stride_w = _o->stride_w;
15347 auto _stride_h = _o->stride_h;
15348 auto _fused_activation_function = _o->fused_activation_function;
15350 _fbb,
15351 _padding,
15352 _stride_w,
15353 _stride_h,
15354 _fused_activation_function);
15355}
15356
15357inline ExpandDimsOptionsT *ExpandDimsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15358 auto _o = std::unique_ptr<ExpandDimsOptionsT>(new ExpandDimsOptionsT());
15359 UnPackTo(_o.get(), _resolver);
15360 return _o.release();
15361}
15362
15363inline void ExpandDimsOptions::UnPackTo(ExpandDimsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15364 (void)_o;
15365 (void)_resolver;
15366}
15367
15368inline flatbuffers::Offset<ExpandDimsOptions> ExpandDimsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15369 return CreateExpandDimsOptions(_fbb, _o, _rehasher);
15370}
15371
15372inline flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15373 (void)_rehasher;
15374 (void)_o;
15375 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExpandDimsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15377 _fbb);
15378}
15379
15380inline SparseToDenseOptionsT *SparseToDenseOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15381 auto _o = std::unique_ptr<SparseToDenseOptionsT>(new SparseToDenseOptionsT());
15382 UnPackTo(_o.get(), _resolver);
15383 return _o.release();
15384}
15385
15386inline void SparseToDenseOptions::UnPackTo(SparseToDenseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15387 (void)_o;
15388 (void)_resolver;
15389 { auto _e = validate_indices(); _o->validate_indices = _e; }
15390}
15391
15392inline flatbuffers::Offset<SparseToDenseOptions> SparseToDenseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15393 return CreateSparseToDenseOptions(_fbb, _o, _rehasher);
15394}
15395
15396inline flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15397 (void)_rehasher;
15398 (void)_o;
15399 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SparseToDenseOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15400 auto _validate_indices = _o->validate_indices;
15402 _fbb,
15403 _validate_indices);
15404}
15405
15406inline EqualOptionsT *EqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15407 auto _o = std::unique_ptr<EqualOptionsT>(new EqualOptionsT());
15408 UnPackTo(_o.get(), _resolver);
15409 return _o.release();
15410}
15411
15412inline void EqualOptions::UnPackTo(EqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15413 (void)_o;
15414 (void)_resolver;
15415}
15416
15417inline flatbuffers::Offset<EqualOptions> EqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15418 return CreateEqualOptions(_fbb, _o, _rehasher);
15419}
15420
15421inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15422 (void)_rehasher;
15423 (void)_o;
15424 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15426 _fbb);
15427}
15428
15429inline NotEqualOptionsT *NotEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15430 auto _o = std::unique_ptr<NotEqualOptionsT>(new NotEqualOptionsT());
15431 UnPackTo(_o.get(), _resolver);
15432 return _o.release();
15433}
15434
15435inline void NotEqualOptions::UnPackTo(NotEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15436 (void)_o;
15437 (void)_resolver;
15438}
15439
15440inline flatbuffers::Offset<NotEqualOptions> NotEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15441 return CreateNotEqualOptions(_fbb, _o, _rehasher);
15442}
15443
15444inline flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15445 (void)_rehasher;
15446 (void)_o;
15447 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NotEqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15449 _fbb);
15450}
15451
15452inline ShapeOptionsT *ShapeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15453 auto _o = std::unique_ptr<ShapeOptionsT>(new ShapeOptionsT());
15454 UnPackTo(_o.get(), _resolver);
15455 return _o.release();
15456}
15457
15458inline void ShapeOptions::UnPackTo(ShapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15459 (void)_o;
15460 (void)_resolver;
15461 { auto _e = out_type(); _o->out_type = _e; }
15462}
15463
15464inline flatbuffers::Offset<ShapeOptions> ShapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15465 return CreateShapeOptions(_fbb, _o, _rehasher);
15466}
15467
15468inline flatbuffers::Offset<ShapeOptions> CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15469 (void)_rehasher;
15470 (void)_o;
15471 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ShapeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15472 auto _out_type = _o->out_type;
15474 _fbb,
15475 _out_type);
15476}
15477
15478inline RankOptionsT *RankOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15479 auto _o = std::unique_ptr<RankOptionsT>(new RankOptionsT());
15480 UnPackTo(_o.get(), _resolver);
15481 return _o.release();
15482}
15483
15484inline void RankOptions::UnPackTo(RankOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15485 (void)_o;
15486 (void)_resolver;
15487}
15488
15489inline flatbuffers::Offset<RankOptions> RankOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15490 return CreateRankOptions(_fbb, _o, _rehasher);
15491}
15492
15493inline flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15494 (void)_rehasher;
15495 (void)_o;
15496 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RankOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15498 _fbb);
15499}
15500
15501inline PowOptionsT *PowOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15502 auto _o = std::unique_ptr<PowOptionsT>(new PowOptionsT());
15503 UnPackTo(_o.get(), _resolver);
15504 return _o.release();
15505}
15506
15507inline void PowOptions::UnPackTo(PowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15508 (void)_o;
15509 (void)_resolver;
15510}
15511
15512inline flatbuffers::Offset<PowOptions> PowOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15513 return CreatePowOptions(_fbb, _o, _rehasher);
15514}
15515
15516inline flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15517 (void)_rehasher;
15518 (void)_o;
15519 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PowOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15521 _fbb);
15522}
15523
15524inline FakeQuantOptionsT *FakeQuantOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15525 auto _o = std::unique_ptr<FakeQuantOptionsT>(new FakeQuantOptionsT());
15526 UnPackTo(_o.get(), _resolver);
15527 return _o.release();
15528}
15529
15530inline void FakeQuantOptions::UnPackTo(FakeQuantOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15531 (void)_o;
15532 (void)_resolver;
15533 { auto _e = min(); _o->min = _e; }
15534 { auto _e = max(); _o->max = _e; }
15535 { auto _e = num_bits(); _o->num_bits = _e; }
15536 { auto _e = narrow_range(); _o->narrow_range = _e; }
15537}
15538
15539inline flatbuffers::Offset<FakeQuantOptions> FakeQuantOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15540 return CreateFakeQuantOptions(_fbb, _o, _rehasher);
15541}
15542
15543inline flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15544 (void)_rehasher;
15545 (void)_o;
15546 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FakeQuantOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15547 auto _min = _o->min;
15548 auto _max = _o->max;
15549 auto _num_bits = _o->num_bits;
15550 auto _narrow_range = _o->narrow_range;
15552 _fbb,
15553 _min,
15554 _max,
15555 _num_bits,
15556 _narrow_range);
15557}
15558
15559inline PackOptionsT *PackOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15560 auto _o = std::unique_ptr<PackOptionsT>(new PackOptionsT());
15561 UnPackTo(_o.get(), _resolver);
15562 return _o.release();
15563}
15564
15565inline void PackOptions::UnPackTo(PackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15566 (void)_o;
15567 (void)_resolver;
15568 { auto _e = values_count(); _o->values_count = _e; }
15569 { auto _e = axis(); _o->axis = _e; }
15570}
15571
15572inline flatbuffers::Offset<PackOptions> PackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15573 return CreatePackOptions(_fbb, _o, _rehasher);
15574}
15575
15576inline flatbuffers::Offset<PackOptions> CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15577 (void)_rehasher;
15578 (void)_o;
15579 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PackOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15580 auto _values_count = _o->values_count;
15581 auto _axis = _o->axis;
15583 _fbb,
15584 _values_count,
15585 _axis);
15586}
15587
15588inline LogicalOrOptionsT *LogicalOrOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15589 auto _o = std::unique_ptr<LogicalOrOptionsT>(new LogicalOrOptionsT());
15590 UnPackTo(_o.get(), _resolver);
15591 return _o.release();
15592}
15593
15594inline void LogicalOrOptions::UnPackTo(LogicalOrOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15595 (void)_o;
15596 (void)_resolver;
15597}
15598
15599inline flatbuffers::Offset<LogicalOrOptions> LogicalOrOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15600 return CreateLogicalOrOptions(_fbb, _o, _rehasher);
15601}
15602
15603inline flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15604 (void)_rehasher;
15605 (void)_o;
15606 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogicalOrOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15608 _fbb);
15609}
15610
15611inline OneHotOptionsT *OneHotOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15612 auto _o = std::unique_ptr<OneHotOptionsT>(new OneHotOptionsT());
15613 UnPackTo(_o.get(), _resolver);
15614 return _o.release();
15615}
15616
15617inline void OneHotOptions::UnPackTo(OneHotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15618 (void)_o;
15619 (void)_resolver;
15620 { auto _e = axis(); _o->axis = _e; }
15621}
15622
15623inline flatbuffers::Offset<OneHotOptions> OneHotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15624 return CreateOneHotOptions(_fbb, _o, _rehasher);
15625}
15626
15627inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15628 (void)_rehasher;
15629 (void)_o;
15630 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OneHotOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15631 auto _axis = _o->axis;
15633 _fbb,
15634 _axis);
15635}
15636
15637inline AbsOptionsT *AbsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15638 auto _o = std::unique_ptr<AbsOptionsT>(new AbsOptionsT());
15639 UnPackTo(_o.get(), _resolver);
15640 return _o.release();
15641}
15642
15643inline void AbsOptions::UnPackTo(AbsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15644 (void)_o;
15645 (void)_resolver;
15646}
15647
15648inline flatbuffers::Offset<AbsOptions> AbsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15649 return CreateAbsOptions(_fbb, _o, _rehasher);
15650}
15651
15652inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15653 (void)_rehasher;
15654 (void)_o;
15655 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AbsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15657 _fbb);
15658}
15659
15660inline HardSwishOptionsT *HardSwishOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15661 auto _o = std::unique_ptr<HardSwishOptionsT>(new HardSwishOptionsT());
15662 UnPackTo(_o.get(), _resolver);
15663 return _o.release();
15664}
15665
15666inline void HardSwishOptions::UnPackTo(HardSwishOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15667 (void)_o;
15668 (void)_resolver;
15669}
15670
15671inline flatbuffers::Offset<HardSwishOptions> HardSwishOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15672 return CreateHardSwishOptions(_fbb, _o, _rehasher);
15673}
15674
15675inline flatbuffers::Offset<HardSwishOptions> CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15676 (void)_rehasher;
15677 (void)_o;
15678 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HardSwishOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15680 _fbb);
15681}
15682
15683inline LogicalAndOptionsT *LogicalAndOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15684 auto _o = std::unique_ptr<LogicalAndOptionsT>(new LogicalAndOptionsT());
15685 UnPackTo(_o.get(), _resolver);
15686 return _o.release();
15687}
15688
15689inline void LogicalAndOptions::UnPackTo(LogicalAndOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15690 (void)_o;
15691 (void)_resolver;
15692}
15693
15694inline flatbuffers::Offset<LogicalAndOptions> LogicalAndOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15695 return CreateLogicalAndOptions(_fbb, _o, _rehasher);
15696}
15697
15698inline flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15699 (void)_rehasher;
15700 (void)_o;
15701 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogicalAndOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15703 _fbb);
15704}
15705
15706inline LogicalNotOptionsT *LogicalNotOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15707 auto _o = std::unique_ptr<LogicalNotOptionsT>(new LogicalNotOptionsT());
15708 UnPackTo(_o.get(), _resolver);
15709 return _o.release();
15710}
15711
15712inline void LogicalNotOptions::UnPackTo(LogicalNotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15713 (void)_o;
15714 (void)_resolver;
15715}
15716
15717inline flatbuffers::Offset<LogicalNotOptions> LogicalNotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15718 return CreateLogicalNotOptions(_fbb, _o, _rehasher);
15719}
15720
15721inline flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15722 (void)_rehasher;
15723 (void)_o;
15724 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogicalNotOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15726 _fbb);
15727}
15728
15729inline UnpackOptionsT *UnpackOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15730 auto _o = std::unique_ptr<UnpackOptionsT>(new UnpackOptionsT());
15731 UnPackTo(_o.get(), _resolver);
15732 return _o.release();
15733}
15734
15735inline void UnpackOptions::UnPackTo(UnpackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15736 (void)_o;
15737 (void)_resolver;
15738 { auto _e = num(); _o->num = _e; }
15739 { auto _e = axis(); _o->axis = _e; }
15740}
15741
15742inline flatbuffers::Offset<UnpackOptions> UnpackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15743 return CreateUnpackOptions(_fbb, _o, _rehasher);
15744}
15745
15746inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15747 (void)_rehasher;
15748 (void)_o;
15749 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnpackOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15750 auto _num = _o->num;
15751 auto _axis = _o->axis;
15753 _fbb,
15754 _num,
15755 _axis);
15756}
15757
15758inline FloorDivOptionsT *FloorDivOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15759 auto _o = std::unique_ptr<FloorDivOptionsT>(new FloorDivOptionsT());
15760 UnPackTo(_o.get(), _resolver);
15761 return _o.release();
15762}
15763
15764inline void FloorDivOptions::UnPackTo(FloorDivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15765 (void)_o;
15766 (void)_resolver;
15767}
15768
15769inline flatbuffers::Offset<FloorDivOptions> FloorDivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15770 return CreateFloorDivOptions(_fbb, _o, _rehasher);
15771}
15772
15773inline flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15774 (void)_rehasher;
15775 (void)_o;
15776 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FloorDivOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15778 _fbb);
15779}
15780
15781inline SquareOptionsT *SquareOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15782 auto _o = std::unique_ptr<SquareOptionsT>(new SquareOptionsT());
15783 UnPackTo(_o.get(), _resolver);
15784 return _o.release();
15785}
15786
15787inline void SquareOptions::UnPackTo(SquareOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15788 (void)_o;
15789 (void)_resolver;
15790}
15791
15792inline flatbuffers::Offset<SquareOptions> SquareOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15793 return CreateSquareOptions(_fbb, _o, _rehasher);
15794}
15795
15796inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15797 (void)_rehasher;
15798 (void)_o;
15799 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SquareOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15801 _fbb);
15802}
15803
15804inline ZerosLikeOptionsT *ZerosLikeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15805 auto _o = std::unique_ptr<ZerosLikeOptionsT>(new ZerosLikeOptionsT());
15806 UnPackTo(_o.get(), _resolver);
15807 return _o.release();
15808}
15809
15810inline void ZerosLikeOptions::UnPackTo(ZerosLikeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15811 (void)_o;
15812 (void)_resolver;
15813}
15814
15815inline flatbuffers::Offset<ZerosLikeOptions> ZerosLikeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15816 return CreateZerosLikeOptions(_fbb, _o, _rehasher);
15817}
15818
15819inline flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15820 (void)_rehasher;
15821 (void)_o;
15822 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ZerosLikeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15824 _fbb);
15825}
15826
15827inline FillOptionsT *FillOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15828 auto _o = std::unique_ptr<FillOptionsT>(new FillOptionsT());
15829 UnPackTo(_o.get(), _resolver);
15830 return _o.release();
15831}
15832
15833inline void FillOptions::UnPackTo(FillOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15834 (void)_o;
15835 (void)_resolver;
15836}
15837
15838inline flatbuffers::Offset<FillOptions> FillOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15839 return CreateFillOptions(_fbb, _o, _rehasher);
15840}
15841
15842inline flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15843 (void)_rehasher;
15844 (void)_o;
15845 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FillOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15847 _fbb);
15848}
15849
15850inline FloorModOptionsT *FloorModOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15851 auto _o = std::unique_ptr<FloorModOptionsT>(new FloorModOptionsT());
15852 UnPackTo(_o.get(), _resolver);
15853 return _o.release();
15854}
15855
15856inline void FloorModOptions::UnPackTo(FloorModOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15857 (void)_o;
15858 (void)_resolver;
15859}
15860
15861inline flatbuffers::Offset<FloorModOptions> FloorModOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15862 return CreateFloorModOptions(_fbb, _o, _rehasher);
15863}
15864
15865inline flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15866 (void)_rehasher;
15867 (void)_o;
15868 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FloorModOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15870 _fbb);
15871}
15872
15873inline RangeOptionsT *RangeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15874 auto _o = std::unique_ptr<RangeOptionsT>(new RangeOptionsT());
15875 UnPackTo(_o.get(), _resolver);
15876 return _o.release();
15877}
15878
15879inline void RangeOptions::UnPackTo(RangeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15880 (void)_o;
15881 (void)_resolver;
15882}
15883
15884inline flatbuffers::Offset<RangeOptions> RangeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15885 return CreateRangeOptions(_fbb, _o, _rehasher);
15886}
15887
15888inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15889 (void)_rehasher;
15890 (void)_o;
15891 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RangeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15893 _fbb);
15894}
15895
15896inline LeakyReluOptionsT *LeakyReluOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15897 auto _o = std::unique_ptr<LeakyReluOptionsT>(new LeakyReluOptionsT());
15898 UnPackTo(_o.get(), _resolver);
15899 return _o.release();
15900}
15901
15902inline void LeakyReluOptions::UnPackTo(LeakyReluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15903 (void)_o;
15904 (void)_resolver;
15905 { auto _e = alpha(); _o->alpha = _e; }
15906}
15907
15908inline flatbuffers::Offset<LeakyReluOptions> LeakyReluOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15909 return CreateLeakyReluOptions(_fbb, _o, _rehasher);
15910}
15911
15912inline flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15913 (void)_rehasher;
15914 (void)_o;
15915 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LeakyReluOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15916 auto _alpha = _o->alpha;
15918 _fbb,
15919 _alpha);
15920}
15921
15922inline SquaredDifferenceOptionsT *SquaredDifferenceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15923 auto _o = std::unique_ptr<SquaredDifferenceOptionsT>(new SquaredDifferenceOptionsT());
15924 UnPackTo(_o.get(), _resolver);
15925 return _o.release();
15926}
15927
15928inline void SquaredDifferenceOptions::UnPackTo(SquaredDifferenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15929 (void)_o;
15930 (void)_resolver;
15931}
15932
15933inline flatbuffers::Offset<SquaredDifferenceOptions> SquaredDifferenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15934 return CreateSquaredDifferenceOptions(_fbb, _o, _rehasher);
15935}
15936
15937inline flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15938 (void)_rehasher;
15939 (void)_o;
15940 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SquaredDifferenceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15942 _fbb);
15943}
15944
15945inline MirrorPadOptionsT *MirrorPadOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15946 auto _o = std::unique_ptr<MirrorPadOptionsT>(new MirrorPadOptionsT());
15947 UnPackTo(_o.get(), _resolver);
15948 return _o.release();
15949}
15950
15951inline void MirrorPadOptions::UnPackTo(MirrorPadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15952 (void)_o;
15953 (void)_resolver;
15954 { auto _e = mode(); _o->mode = _e; }
15955}
15956
15957inline flatbuffers::Offset<MirrorPadOptions> MirrorPadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15958 return CreateMirrorPadOptions(_fbb, _o, _rehasher);
15959}
15960
15961inline flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15962 (void)_rehasher;
15963 (void)_o;
15964 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MirrorPadOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15965 auto _mode = _o->mode;
15967 _fbb,
15968 _mode);
15969}
15970
15971inline UniqueOptionsT *UniqueOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15972 auto _o = std::unique_ptr<UniqueOptionsT>(new UniqueOptionsT());
15973 UnPackTo(_o.get(), _resolver);
15974 return _o.release();
15975}
15976
15977inline void UniqueOptions::UnPackTo(UniqueOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
15978 (void)_o;
15979 (void)_resolver;
15980 { auto _e = idx_out_type(); _o->idx_out_type = _e; }
15981}
15982
15983inline flatbuffers::Offset<UniqueOptions> UniqueOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
15984 return CreateUniqueOptions(_fbb, _o, _rehasher);
15985}
15986
15987inline flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
15988 (void)_rehasher;
15989 (void)_o;
15990 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UniqueOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
15991 auto _idx_out_type = _o->idx_out_type;
15993 _fbb,
15994 _idx_out_type);
15995}
15996
15997inline ReverseV2OptionsT *ReverseV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
15998 auto _o = std::unique_ptr<ReverseV2OptionsT>(new ReverseV2OptionsT());
15999 UnPackTo(_o.get(), _resolver);
16000 return _o.release();
16001}
16002
16003inline void ReverseV2Options::UnPackTo(ReverseV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16004 (void)_o;
16005 (void)_resolver;
16006}
16007
16008inline flatbuffers::Offset<ReverseV2Options> ReverseV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16009 return CreateReverseV2Options(_fbb, _o, _rehasher);
16010}
16011
16012inline flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16013 (void)_rehasher;
16014 (void)_o;
16015 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReverseV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16017 _fbb);
16018}
16019
16020inline AddNOptionsT *AddNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16021 auto _o = std::unique_ptr<AddNOptionsT>(new AddNOptionsT());
16022 UnPackTo(_o.get(), _resolver);
16023 return _o.release();
16024}
16025
16026inline void AddNOptions::UnPackTo(AddNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16027 (void)_o;
16028 (void)_resolver;
16029}
16030
16031inline flatbuffers::Offset<AddNOptions> AddNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16032 return CreateAddNOptions(_fbb, _o, _rehasher);
16033}
16034
16035inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16036 (void)_rehasher;
16037 (void)_o;
16038 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AddNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16040 _fbb);
16041}
16042
16043inline GatherNdOptionsT *GatherNdOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16044 auto _o = std::unique_ptr<GatherNdOptionsT>(new GatherNdOptionsT());
16045 UnPackTo(_o.get(), _resolver);
16046 return _o.release();
16047}
16048
16049inline void GatherNdOptions::UnPackTo(GatherNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16050 (void)_o;
16051 (void)_resolver;
16052}
16053
16054inline flatbuffers::Offset<GatherNdOptions> GatherNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16055 return CreateGatherNdOptions(_fbb, _o, _rehasher);
16056}
16057
16058inline flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16059 (void)_rehasher;
16060 (void)_o;
16061 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GatherNdOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16063 _fbb);
16064}
16065
16066inline WhereOptionsT *WhereOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16067 auto _o = std::unique_ptr<WhereOptionsT>(new WhereOptionsT());
16068 UnPackTo(_o.get(), _resolver);
16069 return _o.release();
16070}
16071
16072inline void WhereOptions::UnPackTo(WhereOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16073 (void)_o;
16074 (void)_resolver;
16075}
16076
16077inline flatbuffers::Offset<WhereOptions> WhereOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16078 return CreateWhereOptions(_fbb, _o, _rehasher);
16079}
16080
16081inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16082 (void)_rehasher;
16083 (void)_o;
16084 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WhereOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16086 _fbb);
16087}
16088
16089inline ReverseSequenceOptionsT *ReverseSequenceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16090 auto _o = std::unique_ptr<ReverseSequenceOptionsT>(new ReverseSequenceOptionsT());
16091 UnPackTo(_o.get(), _resolver);
16092 return _o.release();
16093}
16094
16095inline void ReverseSequenceOptions::UnPackTo(ReverseSequenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16096 (void)_o;
16097 (void)_resolver;
16098 { auto _e = seq_dim(); _o->seq_dim = _e; }
16099 { auto _e = batch_dim(); _o->batch_dim = _e; }
16100}
16101
16102inline flatbuffers::Offset<ReverseSequenceOptions> ReverseSequenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16103 return CreateReverseSequenceOptions(_fbb, _o, _rehasher);
16104}
16105
16106inline flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16107 (void)_rehasher;
16108 (void)_o;
16109 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReverseSequenceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16110 auto _seq_dim = _o->seq_dim;
16111 auto _batch_dim = _o->batch_dim;
16113 _fbb,
16114 _seq_dim,
16115 _batch_dim);
16116}
16117
16118inline MatrixDiagOptionsT *MatrixDiagOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16119 auto _o = std::unique_ptr<MatrixDiagOptionsT>(new MatrixDiagOptionsT());
16120 UnPackTo(_o.get(), _resolver);
16121 return _o.release();
16122}
16123
16124inline void MatrixDiagOptions::UnPackTo(MatrixDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16125 (void)_o;
16126 (void)_resolver;
16127}
16128
16129inline flatbuffers::Offset<MatrixDiagOptions> MatrixDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16130 return CreateMatrixDiagOptions(_fbb, _o, _rehasher);
16131}
16132
16133inline flatbuffers::Offset<MatrixDiagOptions> CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16134 (void)_rehasher;
16135 (void)_o;
16136 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MatrixDiagOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16138 _fbb);
16139}
16140
16141inline QuantizeOptionsT *QuantizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16142 auto _o = std::unique_ptr<QuantizeOptionsT>(new QuantizeOptionsT());
16143 UnPackTo(_o.get(), _resolver);
16144 return _o.release();
16145}
16146
16147inline void QuantizeOptions::UnPackTo(QuantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16148 (void)_o;
16149 (void)_resolver;
16150}
16151
16152inline flatbuffers::Offset<QuantizeOptions> QuantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16153 return CreateQuantizeOptions(_fbb, _o, _rehasher);
16154}
16155
16156inline flatbuffers::Offset<QuantizeOptions> CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16157 (void)_rehasher;
16158 (void)_o;
16159 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16161 _fbb);
16162}
16163
16164inline MatrixSetDiagOptionsT *MatrixSetDiagOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16165 auto _o = std::unique_ptr<MatrixSetDiagOptionsT>(new MatrixSetDiagOptionsT());
16166 UnPackTo(_o.get(), _resolver);
16167 return _o.release();
16168}
16169
16170inline void MatrixSetDiagOptions::UnPackTo(MatrixSetDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16171 (void)_o;
16172 (void)_resolver;
16173}
16174
16175inline flatbuffers::Offset<MatrixSetDiagOptions> MatrixSetDiagOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16176 return CreateMatrixSetDiagOptions(_fbb, _o, _rehasher);
16177}
16178
16179inline flatbuffers::Offset<MatrixSetDiagOptions> CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16180 (void)_rehasher;
16181 (void)_o;
16182 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MatrixSetDiagOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16184 _fbb);
16185}
16186
16187inline IfOptionsT *IfOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16188 auto _o = std::unique_ptr<IfOptionsT>(new IfOptionsT());
16189 UnPackTo(_o.get(), _resolver);
16190 return _o.release();
16191}
16192
16193inline void IfOptions::UnPackTo(IfOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16194 (void)_o;
16195 (void)_resolver;
16196 { auto _e = then_subgraph_index(); _o->then_subgraph_index = _e; }
16197 { auto _e = else_subgraph_index(); _o->else_subgraph_index = _e; }
16198}
16199
16200inline flatbuffers::Offset<IfOptions> IfOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16201 return CreateIfOptions(_fbb, _o, _rehasher);
16202}
16203
16204inline flatbuffers::Offset<IfOptions> CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16205 (void)_rehasher;
16206 (void)_o;
16207 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const IfOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16208 auto _then_subgraph_index = _o->then_subgraph_index;
16209 auto _else_subgraph_index = _o->else_subgraph_index;
16211 _fbb,
16212 _then_subgraph_index,
16213 _else_subgraph_index);
16214}
16215
16216inline CallOnceOptionsT *CallOnceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16217 auto _o = std::unique_ptr<CallOnceOptionsT>(new CallOnceOptionsT());
16218 UnPackTo(_o.get(), _resolver);
16219 return _o.release();
16220}
16221
16222inline void CallOnceOptions::UnPackTo(CallOnceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16223 (void)_o;
16224 (void)_resolver;
16225 { auto _e = init_subgraph_index(); _o->init_subgraph_index = _e; }
16226}
16227
16228inline flatbuffers::Offset<CallOnceOptions> CallOnceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16229 return CreateCallOnceOptions(_fbb, _o, _rehasher);
16230}
16231
16232inline flatbuffers::Offset<CallOnceOptions> CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16233 (void)_rehasher;
16234 (void)_o;
16235 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CallOnceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16236 auto _init_subgraph_index = _o->init_subgraph_index;
16238 _fbb,
16239 _init_subgraph_index);
16240}
16241
16242inline WhileOptionsT *WhileOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16243 auto _o = std::unique_ptr<WhileOptionsT>(new WhileOptionsT());
16244 UnPackTo(_o.get(), _resolver);
16245 return _o.release();
16246}
16247
16248inline void WhileOptions::UnPackTo(WhileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16249 (void)_o;
16250 (void)_resolver;
16251 { auto _e = cond_subgraph_index(); _o->cond_subgraph_index = _e; }
16252 { auto _e = body_subgraph_index(); _o->body_subgraph_index = _e; }
16253}
16254
16255inline flatbuffers::Offset<WhileOptions> WhileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16256 return CreateWhileOptions(_fbb, _o, _rehasher);
16257}
16258
16259inline flatbuffers::Offset<WhileOptions> CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16260 (void)_rehasher;
16261 (void)_o;
16262 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WhileOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16263 auto _cond_subgraph_index = _o->cond_subgraph_index;
16264 auto _body_subgraph_index = _o->body_subgraph_index;
16266 _fbb,
16267 _cond_subgraph_index,
16268 _body_subgraph_index);
16269}
16270
16271inline NonMaxSuppressionV4OptionsT *NonMaxSuppressionV4Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16272 auto _o = std::unique_ptr<NonMaxSuppressionV4OptionsT>(new NonMaxSuppressionV4OptionsT());
16273 UnPackTo(_o.get(), _resolver);
16274 return _o.release();
16275}
16276
16277inline void NonMaxSuppressionV4Options::UnPackTo(NonMaxSuppressionV4OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16278 (void)_o;
16279 (void)_resolver;
16280}
16281
16282inline flatbuffers::Offset<NonMaxSuppressionV4Options> NonMaxSuppressionV4Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16283 return CreateNonMaxSuppressionV4Options(_fbb, _o, _rehasher);
16284}
16285
16286inline flatbuffers::Offset<NonMaxSuppressionV4Options> CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16287 (void)_rehasher;
16288 (void)_o;
16289 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NonMaxSuppressionV4OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16291 _fbb);
16292}
16293
16294inline NonMaxSuppressionV5OptionsT *NonMaxSuppressionV5Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16295 auto _o = std::unique_ptr<NonMaxSuppressionV5OptionsT>(new NonMaxSuppressionV5OptionsT());
16296 UnPackTo(_o.get(), _resolver);
16297 return _o.release();
16298}
16299
16300inline void NonMaxSuppressionV5Options::UnPackTo(NonMaxSuppressionV5OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16301 (void)_o;
16302 (void)_resolver;
16303}
16304
16305inline flatbuffers::Offset<NonMaxSuppressionV5Options> NonMaxSuppressionV5Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16306 return CreateNonMaxSuppressionV5Options(_fbb, _o, _rehasher);
16307}
16308
16309inline flatbuffers::Offset<NonMaxSuppressionV5Options> CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16310 (void)_rehasher;
16311 (void)_o;
16312 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NonMaxSuppressionV5OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16314 _fbb);
16315}
16316
16317inline ScatterNdOptionsT *ScatterNdOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16318 auto _o = std::unique_ptr<ScatterNdOptionsT>(new ScatterNdOptionsT());
16319 UnPackTo(_o.get(), _resolver);
16320 return _o.release();
16321}
16322
16323inline void ScatterNdOptions::UnPackTo(ScatterNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16324 (void)_o;
16325 (void)_resolver;
16326}
16327
16328inline flatbuffers::Offset<ScatterNdOptions> ScatterNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16329 return CreateScatterNdOptions(_fbb, _o, _rehasher);
16330}
16331
16332inline flatbuffers::Offset<ScatterNdOptions> CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16333 (void)_rehasher;
16334 (void)_o;
16335 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ScatterNdOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16337 _fbb);
16338}
16339
16340inline SelectV2OptionsT *SelectV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16341 auto _o = std::unique_ptr<SelectV2OptionsT>(new SelectV2OptionsT());
16342 UnPackTo(_o.get(), _resolver);
16343 return _o.release();
16344}
16345
16346inline void SelectV2Options::UnPackTo(SelectV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16347 (void)_o;
16348 (void)_resolver;
16349}
16350
16351inline flatbuffers::Offset<SelectV2Options> SelectV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16352 return CreateSelectV2Options(_fbb, _o, _rehasher);
16353}
16354
16355inline flatbuffers::Offset<SelectV2Options> CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16356 (void)_rehasher;
16357 (void)_o;
16358 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SelectV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16360 _fbb);
16361}
16362
16363inline DensifyOptionsT *DensifyOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16364 auto _o = std::unique_ptr<DensifyOptionsT>(new DensifyOptionsT());
16365 UnPackTo(_o.get(), _resolver);
16366 return _o.release();
16367}
16368
16369inline void DensifyOptions::UnPackTo(DensifyOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16370 (void)_o;
16371 (void)_resolver;
16372}
16373
16374inline flatbuffers::Offset<DensifyOptions> DensifyOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16375 return CreateDensifyOptions(_fbb, _o, _rehasher);
16376}
16377
16378inline flatbuffers::Offset<DensifyOptions> CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16379 (void)_rehasher;
16380 (void)_o;
16381 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DensifyOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16383 _fbb);
16384}
16385
16386inline SegmentSumOptionsT *SegmentSumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16387 auto _o = std::unique_ptr<SegmentSumOptionsT>(new SegmentSumOptionsT());
16388 UnPackTo(_o.get(), _resolver);
16389 return _o.release();
16390}
16391
16392inline void SegmentSumOptions::UnPackTo(SegmentSumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16393 (void)_o;
16394 (void)_resolver;
16395}
16396
16397inline flatbuffers::Offset<SegmentSumOptions> SegmentSumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16398 return CreateSegmentSumOptions(_fbb, _o, _rehasher);
16399}
16400
16401inline flatbuffers::Offset<SegmentSumOptions> CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16402 (void)_rehasher;
16403 (void)_o;
16404 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SegmentSumOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16406 _fbb);
16407}
16408
16409inline BatchMatMulOptionsT *BatchMatMulOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16410 auto _o = std::unique_ptr<BatchMatMulOptionsT>(new BatchMatMulOptionsT());
16411 UnPackTo(_o.get(), _resolver);
16412 return _o.release();
16413}
16414
16415inline void BatchMatMulOptions::UnPackTo(BatchMatMulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16416 (void)_o;
16417 (void)_resolver;
16418 { auto _e = adj_x(); _o->adj_x = _e; }
16419 { auto _e = adj_y(); _o->adj_y = _e; }
16420 { auto _e = asymmetric_quantize_inputs(); _o->asymmetric_quantize_inputs = _e; }
16421}
16422
16423inline flatbuffers::Offset<BatchMatMulOptions> BatchMatMulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16424 return CreateBatchMatMulOptions(_fbb, _o, _rehasher);
16425}
16426
16427inline flatbuffers::Offset<BatchMatMulOptions> CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16428 (void)_rehasher;
16429 (void)_o;
16430 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BatchMatMulOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16431 auto _adj_x = _o->adj_x;
16432 auto _adj_y = _o->adj_y;
16433 auto _asymmetric_quantize_inputs = _o->asymmetric_quantize_inputs;
16435 _fbb,
16436 _adj_x,
16437 _adj_y,
16438 _asymmetric_quantize_inputs);
16439}
16440
16441inline CumsumOptionsT *CumsumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16442 auto _o = std::unique_ptr<CumsumOptionsT>(new CumsumOptionsT());
16443 UnPackTo(_o.get(), _resolver);
16444 return _o.release();
16445}
16446
16447inline void CumsumOptions::UnPackTo(CumsumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16448 (void)_o;
16449 (void)_resolver;
16450 { auto _e = exclusive(); _o->exclusive = _e; }
16451 { auto _e = reverse(); _o->reverse = _e; }
16452}
16453
16454inline flatbuffers::Offset<CumsumOptions> CumsumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16455 return CreateCumsumOptions(_fbb, _o, _rehasher);
16456}
16457
16458inline flatbuffers::Offset<CumsumOptions> CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16459 (void)_rehasher;
16460 (void)_o;
16461 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CumsumOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16462 auto _exclusive = _o->exclusive;
16463 auto _reverse = _o->reverse;
16465 _fbb,
16466 _exclusive,
16467 _reverse);
16468}
16469
16470inline BroadcastToOptionsT *BroadcastToOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16471 auto _o = std::unique_ptr<BroadcastToOptionsT>(new BroadcastToOptionsT());
16472 UnPackTo(_o.get(), _resolver);
16473 return _o.release();
16474}
16475
16476inline void BroadcastToOptions::UnPackTo(BroadcastToOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16477 (void)_o;
16478 (void)_resolver;
16479}
16480
16481inline flatbuffers::Offset<BroadcastToOptions> BroadcastToOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16482 return CreateBroadcastToOptions(_fbb, _o, _rehasher);
16483}
16484
16485inline flatbuffers::Offset<BroadcastToOptions> CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16486 (void)_rehasher;
16487 (void)_o;
16488 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BroadcastToOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16490 _fbb);
16491}
16492
16493inline Rfft2dOptionsT *Rfft2dOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16494 auto _o = std::unique_ptr<Rfft2dOptionsT>(new Rfft2dOptionsT());
16495 UnPackTo(_o.get(), _resolver);
16496 return _o.release();
16497}
16498
16499inline void Rfft2dOptions::UnPackTo(Rfft2dOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16500 (void)_o;
16501 (void)_resolver;
16502}
16503
16504inline flatbuffers::Offset<Rfft2dOptions> Rfft2dOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16505 return CreateRfft2dOptions(_fbb, _o, _rehasher);
16506}
16507
16508inline flatbuffers::Offset<Rfft2dOptions> CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16509 (void)_rehasher;
16510 (void)_o;
16511 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Rfft2dOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16513 _fbb);
16514}
16515
16516inline HashtableOptionsT *HashtableOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16517 auto _o = std::unique_ptr<HashtableOptionsT>(new HashtableOptionsT());
16518 UnPackTo(_o.get(), _resolver);
16519 return _o.release();
16520}
16521
16522inline void HashtableOptions::UnPackTo(HashtableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16523 (void)_o;
16524 (void)_resolver;
16525 { auto _e = table_id(); _o->table_id = _e; }
16526 { auto _e = key_dtype(); _o->key_dtype = _e; }
16527 { auto _e = value_dtype(); _o->value_dtype = _e; }
16528}
16529
16530inline flatbuffers::Offset<HashtableOptions> HashtableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16531 return CreateHashtableOptions(_fbb, _o, _rehasher);
16532}
16533
16534inline flatbuffers::Offset<HashtableOptions> CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16535 (void)_rehasher;
16536 (void)_o;
16537 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HashtableOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16538 auto _table_id = _o->table_id;
16539 auto _key_dtype = _o->key_dtype;
16540 auto _value_dtype = _o->value_dtype;
16542 _fbb,
16543 _table_id,
16544 _key_dtype,
16545 _value_dtype);
16546}
16547
16548inline HashtableFindOptionsT *HashtableFindOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16549 auto _o = std::unique_ptr<HashtableFindOptionsT>(new HashtableFindOptionsT());
16550 UnPackTo(_o.get(), _resolver);
16551 return _o.release();
16552}
16553
16554inline void HashtableFindOptions::UnPackTo(HashtableFindOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16555 (void)_o;
16556 (void)_resolver;
16557}
16558
16559inline flatbuffers::Offset<HashtableFindOptions> HashtableFindOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16560 return CreateHashtableFindOptions(_fbb, _o, _rehasher);
16561}
16562
16563inline flatbuffers::Offset<HashtableFindOptions> CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16564 (void)_rehasher;
16565 (void)_o;
16566 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HashtableFindOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16568 _fbb);
16569}
16570
16571inline HashtableImportOptionsT *HashtableImportOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16572 auto _o = std::unique_ptr<HashtableImportOptionsT>(new HashtableImportOptionsT());
16573 UnPackTo(_o.get(), _resolver);
16574 return _o.release();
16575}
16576
16577inline void HashtableImportOptions::UnPackTo(HashtableImportOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16578 (void)_o;
16579 (void)_resolver;
16580}
16581
16582inline flatbuffers::Offset<HashtableImportOptions> HashtableImportOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16583 return CreateHashtableImportOptions(_fbb, _o, _rehasher);
16584}
16585
16586inline flatbuffers::Offset<HashtableImportOptions> CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16587 (void)_rehasher;
16588 (void)_o;
16589 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HashtableImportOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16591 _fbb);
16592}
16593
16594inline HashtableSizeOptionsT *HashtableSizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16595 auto _o = std::unique_ptr<HashtableSizeOptionsT>(new HashtableSizeOptionsT());
16596 UnPackTo(_o.get(), _resolver);
16597 return _o.release();
16598}
16599
16600inline void HashtableSizeOptions::UnPackTo(HashtableSizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16601 (void)_o;
16602 (void)_resolver;
16603}
16604
16605inline flatbuffers::Offset<HashtableSizeOptions> HashtableSizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16606 return CreateHashtableSizeOptions(_fbb, _o, _rehasher);
16607}
16608
16609inline flatbuffers::Offset<HashtableSizeOptions> CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16610 (void)_rehasher;
16611 (void)_o;
16612 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HashtableSizeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16614 _fbb);
16615}
16616
16617inline VarHandleOptionsT *VarHandleOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16618 auto _o = std::unique_ptr<VarHandleOptionsT>(new VarHandleOptionsT());
16619 UnPackTo(_o.get(), _resolver);
16620 return _o.release();
16621}
16622
16623inline void VarHandleOptions::UnPackTo(VarHandleOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16624 (void)_o;
16625 (void)_resolver;
16626 { auto _e = container(); if (_e) _o->container = _e->str(); }
16627 { auto _e = shared_name(); if (_e) _o->shared_name = _e->str(); }
16628}
16629
16630inline flatbuffers::Offset<VarHandleOptions> VarHandleOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16631 return CreateVarHandleOptions(_fbb, _o, _rehasher);
16632}
16633
16634inline flatbuffers::Offset<VarHandleOptions> CreateVarHandleOptions(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16635 (void)_rehasher;
16636 (void)_o;
16637 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const VarHandleOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16638 auto _container = _o->container.empty() ? 0 : _fbb.CreateString(_o->container);
16639 auto _shared_name = _o->shared_name.empty() ? 0 : _fbb.CreateString(_o->shared_name);
16641 _fbb,
16642 _container,
16643 _shared_name);
16644}
16645
16646inline ReadVariableOptionsT *ReadVariableOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16647 auto _o = std::unique_ptr<ReadVariableOptionsT>(new ReadVariableOptionsT());
16648 UnPackTo(_o.get(), _resolver);
16649 return _o.release();
16650}
16651
16652inline void ReadVariableOptions::UnPackTo(ReadVariableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16653 (void)_o;
16654 (void)_resolver;
16655}
16656
16657inline flatbuffers::Offset<ReadVariableOptions> ReadVariableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16658 return CreateReadVariableOptions(_fbb, _o, _rehasher);
16659}
16660
16661inline flatbuffers::Offset<ReadVariableOptions> CreateReadVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16662 (void)_rehasher;
16663 (void)_o;
16664 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReadVariableOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16666 _fbb);
16667}
16668
16669inline AssignVariableOptionsT *AssignVariableOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16670 auto _o = std::unique_ptr<AssignVariableOptionsT>(new AssignVariableOptionsT());
16671 UnPackTo(_o.get(), _resolver);
16672 return _o.release();
16673}
16674
16675inline void AssignVariableOptions::UnPackTo(AssignVariableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16676 (void)_o;
16677 (void)_resolver;
16678}
16679
16680inline flatbuffers::Offset<AssignVariableOptions> AssignVariableOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16681 return CreateAssignVariableOptions(_fbb, _o, _rehasher);
16682}
16683
16684inline flatbuffers::Offset<AssignVariableOptions> CreateAssignVariableOptions(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16685 (void)_rehasher;
16686 (void)_o;
16687 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AssignVariableOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16689 _fbb);
16690}
16691
16692inline RandomOptionsT *RandomOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16693 auto _o = std::unique_ptr<RandomOptionsT>(new RandomOptionsT());
16694 UnPackTo(_o.get(), _resolver);
16695 return _o.release();
16696}
16697
16698inline void RandomOptions::UnPackTo(RandomOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16699 (void)_o;
16700 (void)_resolver;
16701 { auto _e = seed(); _o->seed = _e; }
16702 { auto _e = seed2(); _o->seed2 = _e; }
16703}
16704
16705inline flatbuffers::Offset<RandomOptions> RandomOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16706 return CreateRandomOptions(_fbb, _o, _rehasher);
16707}
16708
16709inline flatbuffers::Offset<RandomOptions> CreateRandomOptions(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16710 (void)_rehasher;
16711 (void)_o;
16712 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RandomOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16713 auto _seed = _o->seed;
16714 auto _seed2 = _o->seed2;
16716 _fbb,
16717 _seed,
16718 _seed2);
16719}
16720
16721inline BucketizeOptionsT *BucketizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16722 auto _o = std::unique_ptr<BucketizeOptionsT>(new BucketizeOptionsT());
16723 UnPackTo(_o.get(), _resolver);
16724 return _o.release();
16725}
16726
16727inline void BucketizeOptions::UnPackTo(BucketizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16728 (void)_o;
16729 (void)_resolver;
16730 { auto _e = boundaries(); if (_e) { _o->boundaries.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->boundaries[_i] = _e->Get(_i); } } }
16731}
16732
16733inline flatbuffers::Offset<BucketizeOptions> BucketizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16734 return CreateBucketizeOptions(_fbb, _o, _rehasher);
16735}
16736
16737inline flatbuffers::Offset<BucketizeOptions> CreateBucketizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16738 (void)_rehasher;
16739 (void)_o;
16740 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BucketizeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16741 auto _boundaries = _o->boundaries.size() ? _fbb.CreateVector(_o->boundaries) : 0;
16743 _fbb,
16744 _boundaries);
16745}
16746
16747inline GeluOptionsT *GeluOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16748 auto _o = std::unique_ptr<GeluOptionsT>(new GeluOptionsT());
16749 UnPackTo(_o.get(), _resolver);
16750 return _o.release();
16751}
16752
16753inline void GeluOptions::UnPackTo(GeluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16754 (void)_o;
16755 (void)_resolver;
16756 { auto _e = approximate(); _o->approximate = _e; }
16757}
16758
16759inline flatbuffers::Offset<GeluOptions> GeluOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16760 return CreateGeluOptions(_fbb, _o, _rehasher);
16761}
16762
16763inline flatbuffers::Offset<GeluOptions> CreateGeluOptions(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16764 (void)_rehasher;
16765 (void)_o;
16766 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GeluOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16767 auto _approximate = _o->approximate;
16769 _fbb,
16770 _approximate);
16771}
16772
16773inline DynamicUpdateSliceOptionsT *DynamicUpdateSliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16774 auto _o = std::unique_ptr<DynamicUpdateSliceOptionsT>(new DynamicUpdateSliceOptionsT());
16775 UnPackTo(_o.get(), _resolver);
16776 return _o.release();
16777}
16778
16779inline void DynamicUpdateSliceOptions::UnPackTo(DynamicUpdateSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16780 (void)_o;
16781 (void)_resolver;
16782}
16783
16784inline flatbuffers::Offset<DynamicUpdateSliceOptions> DynamicUpdateSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16785 return CreateDynamicUpdateSliceOptions(_fbb, _o, _rehasher);
16786}
16787
16788inline flatbuffers::Offset<DynamicUpdateSliceOptions> CreateDynamicUpdateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16789 (void)_rehasher;
16790 (void)_o;
16791 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DynamicUpdateSliceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16793 _fbb);
16794}
16795
16796inline UnsortedSegmentProdOptionsT *UnsortedSegmentProdOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16797 auto _o = std::unique_ptr<UnsortedSegmentProdOptionsT>(new UnsortedSegmentProdOptionsT());
16798 UnPackTo(_o.get(), _resolver);
16799 return _o.release();
16800}
16801
16802inline void UnsortedSegmentProdOptions::UnPackTo(UnsortedSegmentProdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16803 (void)_o;
16804 (void)_resolver;
16805}
16806
16807inline flatbuffers::Offset<UnsortedSegmentProdOptions> UnsortedSegmentProdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16808 return CreateUnsortedSegmentProdOptions(_fbb, _o, _rehasher);
16809}
16810
16811inline flatbuffers::Offset<UnsortedSegmentProdOptions> CreateUnsortedSegmentProdOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16812 (void)_rehasher;
16813 (void)_o;
16814 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnsortedSegmentProdOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16816 _fbb);
16817}
16818
16819inline UnsortedSegmentMaxOptionsT *UnsortedSegmentMaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16820 auto _o = std::unique_ptr<UnsortedSegmentMaxOptionsT>(new UnsortedSegmentMaxOptionsT());
16821 UnPackTo(_o.get(), _resolver);
16822 return _o.release();
16823}
16824
16825inline void UnsortedSegmentMaxOptions::UnPackTo(UnsortedSegmentMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16826 (void)_o;
16827 (void)_resolver;
16828}
16829
16830inline flatbuffers::Offset<UnsortedSegmentMaxOptions> UnsortedSegmentMaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16831 return CreateUnsortedSegmentMaxOptions(_fbb, _o, _rehasher);
16832}
16833
16834inline flatbuffers::Offset<UnsortedSegmentMaxOptions> CreateUnsortedSegmentMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16835 (void)_rehasher;
16836 (void)_o;
16837 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnsortedSegmentMaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16839 _fbb);
16840}
16841
16842inline UnsortedSegmentSumOptionsT *UnsortedSegmentSumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16843 auto _o = std::unique_ptr<UnsortedSegmentSumOptionsT>(new UnsortedSegmentSumOptionsT());
16844 UnPackTo(_o.get(), _resolver);
16845 return _o.release();
16846}
16847
16848inline void UnsortedSegmentSumOptions::UnPackTo(UnsortedSegmentSumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16849 (void)_o;
16850 (void)_resolver;
16851}
16852
16853inline flatbuffers::Offset<UnsortedSegmentSumOptions> UnsortedSegmentSumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16854 return CreateUnsortedSegmentSumOptions(_fbb, _o, _rehasher);
16855}
16856
16857inline flatbuffers::Offset<UnsortedSegmentSumOptions> CreateUnsortedSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16858 (void)_rehasher;
16859 (void)_o;
16860 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnsortedSegmentSumOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16862 _fbb);
16863}
16864
16865inline ATan2OptionsT *ATan2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16866 auto _o = std::unique_ptr<ATan2OptionsT>(new ATan2OptionsT());
16867 UnPackTo(_o.get(), _resolver);
16868 return _o.release();
16869}
16870
16871inline void ATan2Options::UnPackTo(ATan2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16872 (void)_o;
16873 (void)_resolver;
16874}
16875
16876inline flatbuffers::Offset<ATan2Options> ATan2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16877 return CreateATan2Options(_fbb, _o, _rehasher);
16878}
16879
16880inline flatbuffers::Offset<ATan2Options> CreateATan2Options(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16881 (void)_rehasher;
16882 (void)_o;
16883 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ATan2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16885 _fbb);
16886}
16887
16888inline UnsortedSegmentMinOptionsT *UnsortedSegmentMinOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16889 auto _o = std::unique_ptr<UnsortedSegmentMinOptionsT>(new UnsortedSegmentMinOptionsT());
16890 UnPackTo(_o.get(), _resolver);
16891 return _o.release();
16892}
16893
16894inline void UnsortedSegmentMinOptions::UnPackTo(UnsortedSegmentMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16895 (void)_o;
16896 (void)_resolver;
16897}
16898
16899inline flatbuffers::Offset<UnsortedSegmentMinOptions> UnsortedSegmentMinOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16900 return CreateUnsortedSegmentMinOptions(_fbb, _o, _rehasher);
16901}
16902
16903inline flatbuffers::Offset<UnsortedSegmentMinOptions> CreateUnsortedSegmentMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16904 (void)_rehasher;
16905 (void)_o;
16906 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnsortedSegmentMinOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16908 _fbb);
16909}
16910
16911inline SignOptionsT *SignOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16912 auto _o = std::unique_ptr<SignOptionsT>(new SignOptionsT());
16913 UnPackTo(_o.get(), _resolver);
16914 return _o.release();
16915}
16916
16917inline void SignOptions::UnPackTo(SignOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16918 (void)_o;
16919 (void)_resolver;
16920}
16921
16922inline flatbuffers::Offset<SignOptions> SignOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16923 return CreateSignOptions(_fbb, _o, _rehasher);
16924}
16925
16926inline flatbuffers::Offset<SignOptions> CreateSignOptions(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16927 (void)_rehasher;
16928 (void)_o;
16929 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SignOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16931 _fbb);
16932}
16933
16934inline OperatorCodeT *OperatorCode::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16935 auto _o = std::unique_ptr<OperatorCodeT>(new OperatorCodeT());
16936 UnPackTo(_o.get(), _resolver);
16937 return _o.release();
16938}
16939
16940inline void OperatorCode::UnPackTo(OperatorCodeT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16941 (void)_o;
16942 (void)_resolver;
16943 { auto _e = deprecated_builtin_code(); _o->deprecated_builtin_code = _e; }
16944 { auto _e = custom_code(); if (_e) _o->custom_code = _e->str(); }
16945 { auto _e = version(); _o->version = _e; }
16946 { auto _e = builtin_code(); _o->builtin_code = _e; }
16947}
16948
16949inline flatbuffers::Offset<OperatorCode> OperatorCode::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16950 return CreateOperatorCode(_fbb, _o, _rehasher);
16951}
16952
16953inline flatbuffers::Offset<OperatorCode> CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16954 (void)_rehasher;
16955 (void)_o;
16956 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OperatorCodeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16957 auto _deprecated_builtin_code = _o->deprecated_builtin_code;
16958 auto _custom_code = _o->custom_code.empty() ? 0 : _fbb.CreateString(_o->custom_code);
16959 auto _version = _o->version;
16960 auto _builtin_code = _o->builtin_code;
16962 _fbb,
16963 _deprecated_builtin_code,
16964 _custom_code,
16965 _version,
16966 _builtin_code);
16967}
16968
16969inline OperatorT *Operator::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
16970 auto _o = std::unique_ptr<OperatorT>(new OperatorT());
16971 UnPackTo(_o.get(), _resolver);
16972 return _o.release();
16973}
16974
16975inline void Operator::UnPackTo(OperatorT *_o, const flatbuffers::resolver_function_t *_resolver) const {
16976 (void)_o;
16977 (void)_resolver;
16978 { auto _e = opcode_index(); _o->opcode_index = _e; }
16979 { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } }
16980 { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } }
16981 { auto _e = builtin_options_type(); _o->builtin_options.type = _e; }
16982 { auto _e = builtin_options(); if (_e) _o->builtin_options.value = tflite::BuiltinOptionsUnion::UnPack(_e, builtin_options_type(), _resolver); }
16983 { auto _e = custom_options(); if (_e) { _o->custom_options.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->custom_options.begin()); } }
16984 { auto _e = custom_options_format(); _o->custom_options_format = _e; }
16985 { auto _e = mutating_variable_inputs(); if (_e) { _o->mutating_variable_inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mutating_variable_inputs[_i] = _e->Get(_i) != 0; } } }
16986 { auto _e = intermediates(); if (_e) { _o->intermediates.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->intermediates[_i] = _e->Get(_i); } } }
16987}
16988
16989inline flatbuffers::Offset<Operator> Operator::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
16990 return CreateOperator(_fbb, _o, _rehasher);
16991}
16992
16993inline flatbuffers::Offset<Operator> CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
16994 (void)_rehasher;
16995 (void)_o;
16996 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OperatorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
16997 auto _opcode_index = _o->opcode_index;
16998 auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : 0;
16999 auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : 0;
17000 auto _builtin_options_type = _o->builtin_options.type;
17001 auto _builtin_options = _o->builtin_options.Pack(_fbb);
17002 auto _custom_options = _o->custom_options.size() ? _fbb.CreateVector(_o->custom_options) : 0;
17003 auto _custom_options_format = _o->custom_options_format;
17004 auto _mutating_variable_inputs = _o->mutating_variable_inputs.size() ? _fbb.CreateVector(_o->mutating_variable_inputs) : 0;
17005 auto _intermediates = _o->intermediates.size() ? _fbb.CreateVector(_o->intermediates) : 0;
17007 _fbb,
17008 _opcode_index,
17009 _inputs,
17010 _outputs,
17011 _builtin_options_type,
17012 _builtin_options,
17013 _custom_options,
17014 _custom_options_format,
17015 _mutating_variable_inputs,
17016 _intermediates);
17017}
17018
17020 : inputs(o.inputs),
17021 outputs(o.outputs),
17022 name(o.name) {
17023 tensors.reserve(o.tensors.size());
17024 for (const auto &tensors_ : o.tensors) { tensors.emplace_back((tensors_) ? new tflite::TensorT(*tensors_) : nullptr); }
17025 operators.reserve(o.operators.size());
17026 for (const auto &operators_ : o.operators) { operators.emplace_back((operators_) ? new tflite::OperatorT(*operators_) : nullptr); }
17027}
17028
17029inline SubGraphT &SubGraphT::operator=(SubGraphT o) FLATBUFFERS_NOEXCEPT {
17030 std::swap(tensors, o.tensors);
17031 std::swap(inputs, o.inputs);
17032 std::swap(outputs, o.outputs);
17033 std::swap(operators, o.operators);
17034 std::swap(name, o.name);
17035 return *this;
17036}
17037
17038inline SubGraphT *SubGraph::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
17039 auto _o = std::unique_ptr<SubGraphT>(new SubGraphT());
17040 UnPackTo(_o.get(), _resolver);
17041 return _o.release();
17042}
17043
17044inline void SubGraph::UnPackTo(SubGraphT *_o, const flatbuffers::resolver_function_t *_resolver) const {
17045 (void)_o;
17046 (void)_resolver;
17047 { auto _e = tensors(); if (_e) { _o->tensors.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->tensors[_i]) { _e->Get(_i)->UnPackTo(_o->tensors[_i].get(), _resolver); } else { _o->tensors[_i] = std::unique_ptr<tflite::TensorT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17048 { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } }
17049 { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } }
17050 { auto _e = operators(); if (_e) { _o->operators.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->operators[_i]) { _e->Get(_i)->UnPackTo(_o->operators[_i].get(), _resolver); } else { _o->operators[_i] = std::unique_ptr<tflite::OperatorT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17051 { auto _e = name(); if (_e) _o->name = _e->str(); }
17052}
17053
17054inline flatbuffers::Offset<SubGraph> SubGraph::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
17055 return CreateSubGraph(_fbb, _o, _rehasher);
17056}
17057
17058inline flatbuffers::Offset<SubGraph> CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
17059 (void)_rehasher;
17060 (void)_o;
17061 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SubGraphT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
17062 auto _tensors = _o->tensors.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Tensor>> (_o->tensors.size(), [](size_t i, _VectorArgs *__va) { return CreateTensor(*__va->__fbb, __va->__o->tensors[i].get(), __va->__rehasher); }, &_va ) : 0;
17063 auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : 0;
17064 auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : 0;
17065 auto _operators = _o->operators.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Operator>> (_o->operators.size(), [](size_t i, _VectorArgs *__va) { return CreateOperator(*__va->__fbb, __va->__o->operators[i].get(), __va->__rehasher); }, &_va ) : 0;
17066 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
17068 _fbb,
17069 _tensors,
17070 _inputs,
17071 _outputs,
17072 _operators,
17073 _name);
17074}
17075
17076inline BufferT *Buffer::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
17077 auto _o = std::unique_ptr<BufferT>(new BufferT());
17078 UnPackTo(_o.get(), _resolver);
17079 return _o.release();
17080}
17081
17082inline void Buffer::UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t *_resolver) const {
17083 (void)_o;
17084 (void)_resolver;
17085 { auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } }
17086}
17087
17088inline flatbuffers::Offset<Buffer> Buffer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
17089 return CreateBuffer(_fbb, _o, _rehasher);
17090}
17091
17092inline flatbuffers::Offset<Buffer> CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
17093 (void)_rehasher;
17094 (void)_o;
17095 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BufferT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
17096 _fbb.ForceVectorAlignment(_o->data.size(), sizeof(uint8_t), 16);
17097 auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0;
17098 return tflite::CreateBuffer(
17099 _fbb,
17100 _data);
17101}
17102
17103inline MetadataT *Metadata::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
17104 auto _o = std::unique_ptr<MetadataT>(new MetadataT());
17105 UnPackTo(_o.get(), _resolver);
17106 return _o.release();
17107}
17108
17109inline void Metadata::UnPackTo(MetadataT *_o, const flatbuffers::resolver_function_t *_resolver) const {
17110 (void)_o;
17111 (void)_resolver;
17112 { auto _e = name(); if (_e) _o->name = _e->str(); }
17113 { auto _e = buffer(); _o->buffer = _e; }
17114}
17115
17116inline flatbuffers::Offset<Metadata> Metadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
17117 return CreateMetadata(_fbb, _o, _rehasher);
17118}
17119
17120inline flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
17121 (void)_rehasher;
17122 (void)_o;
17123 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MetadataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
17124 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
17125 auto _buffer = _o->buffer;
17127 _fbb,
17128 _name,
17129 _buffer);
17130}
17131
17132inline TensorMapT *TensorMap::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
17133 auto _o = std::unique_ptr<TensorMapT>(new TensorMapT());
17134 UnPackTo(_o.get(), _resolver);
17135 return _o.release();
17136}
17137
17138inline void TensorMap::UnPackTo(TensorMapT *_o, const flatbuffers::resolver_function_t *_resolver) const {
17139 (void)_o;
17140 (void)_resolver;
17141 { auto _e = name(); if (_e) _o->name = _e->str(); }
17142 { auto _e = tensor_index(); _o->tensor_index = _e; }
17143}
17144
17145inline flatbuffers::Offset<TensorMap> TensorMap::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
17146 return CreateTensorMap(_fbb, _o, _rehasher);
17147}
17148
17149inline flatbuffers::Offset<TensorMap> CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
17150 (void)_rehasher;
17151 (void)_o;
17152 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TensorMapT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
17153 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
17154 auto _tensor_index = _o->tensor_index;
17156 _fbb,
17157 _name,
17158 _tensor_index);
17159}
17160
17162 : signature_key(o.signature_key),
17163 subgraph_index(o.subgraph_index) {
17164 inputs.reserve(o.inputs.size());
17165 for (const auto &inputs_ : o.inputs) { inputs.emplace_back((inputs_) ? new tflite::TensorMapT(*inputs_) : nullptr); }
17166 outputs.reserve(o.outputs.size());
17167 for (const auto &outputs_ : o.outputs) { outputs.emplace_back((outputs_) ? new tflite::TensorMapT(*outputs_) : nullptr); }
17168}
17169
17171 std::swap(inputs, o.inputs);
17172 std::swap(outputs, o.outputs);
17173 std::swap(signature_key, o.signature_key);
17174 std::swap(subgraph_index, o.subgraph_index);
17175 return *this;
17176}
17177
17178inline SignatureDefT *SignatureDef::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
17179 auto _o = std::unique_ptr<SignatureDefT>(new SignatureDefT());
17180 UnPackTo(_o.get(), _resolver);
17181 return _o.release();
17182}
17183
17184inline void SignatureDef::UnPackTo(SignatureDefT *_o, const flatbuffers::resolver_function_t *_resolver) const {
17185 (void)_o;
17186 (void)_resolver;
17187 { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->inputs[_i]) { _e->Get(_i)->UnPackTo(_o->inputs[_i].get(), _resolver); } else { _o->inputs[_i] = std::unique_ptr<tflite::TensorMapT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17188 { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->outputs[_i]) { _e->Get(_i)->UnPackTo(_o->outputs[_i].get(), _resolver); } else { _o->outputs[_i] = std::unique_ptr<tflite::TensorMapT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17189 { auto _e = signature_key(); if (_e) _o->signature_key = _e->str(); }
17190 { auto _e = subgraph_index(); _o->subgraph_index = _e; }
17191}
17192
17193inline flatbuffers::Offset<SignatureDef> SignatureDef::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
17194 return CreateSignatureDef(_fbb, _o, _rehasher);
17195}
17196
17197inline flatbuffers::Offset<SignatureDef> CreateSignatureDef(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
17198 (void)_rehasher;
17199 (void)_o;
17200 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SignatureDefT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
17201 auto _inputs = _o->inputs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>> (_o->inputs.size(), [](size_t i, _VectorArgs *__va) { return CreateTensorMap(*__va->__fbb, __va->__o->inputs[i].get(), __va->__rehasher); }, &_va ) : 0;
17202 auto _outputs = _o->outputs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMap>> (_o->outputs.size(), [](size_t i, _VectorArgs *__va) { return CreateTensorMap(*__va->__fbb, __va->__o->outputs[i].get(), __va->__rehasher); }, &_va ) : 0;
17203 auto _signature_key = _o->signature_key.empty() ? 0 : _fbb.CreateString(_o->signature_key);
17204 auto _subgraph_index = _o->subgraph_index;
17206 _fbb,
17207 _inputs,
17208 _outputs,
17209 _signature_key,
17210 _subgraph_index);
17211}
17212
17213inline ModelT::ModelT(const ModelT &o)
17214 : version(o.version),
17215 description(o.description),
17216 metadata_buffer(o.metadata_buffer) {
17217 operator_codes.reserve(o.operator_codes.size());
17218 for (const auto &operator_codes_ : o.operator_codes) { operator_codes.emplace_back((operator_codes_) ? new tflite::OperatorCodeT(*operator_codes_) : nullptr); }
17219 subgraphs.reserve(o.subgraphs.size());
17220 for (const auto &subgraphs_ : o.subgraphs) { subgraphs.emplace_back((subgraphs_) ? new tflite::SubGraphT(*subgraphs_) : nullptr); }
17221 buffers.reserve(o.buffers.size());
17222 for (const auto &buffers_ : o.buffers) { buffers.emplace_back((buffers_) ? new tflite::BufferT(*buffers_) : nullptr); }
17223 metadata.reserve(o.metadata.size());
17224 for (const auto &metadata_ : o.metadata) { metadata.emplace_back((metadata_) ? new tflite::MetadataT(*metadata_) : nullptr); }
17225 signature_defs.reserve(o.signature_defs.size());
17226 for (const auto &signature_defs_ : o.signature_defs) { signature_defs.emplace_back((signature_defs_) ? new tflite::SignatureDefT(*signature_defs_) : nullptr); }
17227}
17228
17229inline ModelT &ModelT::operator=(ModelT o) FLATBUFFERS_NOEXCEPT {
17230 std::swap(version, o.version);
17231 std::swap(operator_codes, o.operator_codes);
17232 std::swap(subgraphs, o.subgraphs);
17233 std::swap(description, o.description);
17234 std::swap(buffers, o.buffers);
17235 std::swap(metadata_buffer, o.metadata_buffer);
17236 std::swap(metadata, o.metadata);
17237 std::swap(signature_defs, o.signature_defs);
17238 return *this;
17239}
17240
17241inline ModelT *Model::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
17242 auto _o = std::unique_ptr<ModelT>(new ModelT());
17243 UnPackTo(_o.get(), _resolver);
17244 return _o.release();
17245}
17246
17247inline void Model::UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver) const {
17248 (void)_o;
17249 (void)_resolver;
17250 { auto _e = version(); _o->version = _e; }
17251 { auto _e = operator_codes(); if (_e) { _o->operator_codes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->operator_codes[_i]) { _e->Get(_i)->UnPackTo(_o->operator_codes[_i].get(), _resolver); } else { _o->operator_codes[_i] = std::unique_ptr<tflite::OperatorCodeT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17252 { auto _e = subgraphs(); if (_e) { _o->subgraphs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->subgraphs[_i]) { _e->Get(_i)->UnPackTo(_o->subgraphs[_i].get(), _resolver); } else { _o->subgraphs[_i] = std::unique_ptr<tflite::SubGraphT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17253 { auto _e = description(); if (_e) _o->description = _e->str(); }
17254 { auto _e = buffers(); if (_e) { _o->buffers.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->buffers[_i]) { _e->Get(_i)->UnPackTo(_o->buffers[_i].get(), _resolver); } else { _o->buffers[_i] = std::unique_ptr<tflite::BufferT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17255 { auto _e = metadata_buffer(); if (_e) { _o->metadata_buffer.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->metadata_buffer[_i] = _e->Get(_i); } } }
17256 { auto _e = metadata(); if (_e) { _o->metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->metadata[_i]) { _e->Get(_i)->UnPackTo(_o->metadata[_i].get(), _resolver); } else { _o->metadata[_i] = std::unique_ptr<tflite::MetadataT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17257 { auto _e = signature_defs(); if (_e) { _o->signature_defs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->signature_defs[_i]) { _e->Get(_i)->UnPackTo(_o->signature_defs[_i].get(), _resolver); } else { _o->signature_defs[_i] = std::unique_ptr<tflite::SignatureDefT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
17258}
17259
17260inline flatbuffers::Offset<Model> Model::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
17261 return CreateModel(_fbb, _o, _rehasher);
17262}
17263
17264inline flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
17265 (void)_rehasher;
17266 (void)_o;
17267 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ModelT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
17268 auto _version = _o->version;
17269 auto _operator_codes = _o->operator_codes.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::OperatorCode>> (_o->operator_codes.size(), [](size_t i, _VectorArgs *__va) { return CreateOperatorCode(*__va->__fbb, __va->__o->operator_codes[i].get(), __va->__rehasher); }, &_va ) : 0;
17270 auto _subgraphs = _o->subgraphs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::SubGraph>> (_o->subgraphs.size(), [](size_t i, _VectorArgs *__va) { return CreateSubGraph(*__va->__fbb, __va->__o->subgraphs[i].get(), __va->__rehasher); }, &_va ) : 0;
17271 auto _description = _o->description.empty() ? 0 : _fbb.CreateString(_o->description);
17272 auto _buffers = _o->buffers.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Buffer>> (_o->buffers.size(), [](size_t i, _VectorArgs *__va) { return CreateBuffer(*__va->__fbb, __va->__o->buffers[i].get(), __va->__rehasher); }, &_va ) : 0;
17273 auto _metadata_buffer = _o->metadata_buffer.size() ? _fbb.CreateVector(_o->metadata_buffer) : 0;
17274 auto _metadata = _o->metadata.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::Metadata>> (_o->metadata.size(), [](size_t i, _VectorArgs *__va) { return CreateMetadata(*__va->__fbb, __va->__o->metadata[i].get(), __va->__rehasher); }, &_va ) : 0;
17275 auto _signature_defs = _o->signature_defs.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::SignatureDef>> (_o->signature_defs.size(), [](size_t i, _VectorArgs *__va) { return CreateSignatureDef(*__va->__fbb, __va->__o->signature_defs[i].get(), __va->__rehasher); }, &_va ) : 0;
17276 return tflite::CreateModel(
17277 _fbb,
17278 _version,
17279 _operator_codes,
17280 _subgraphs,
17281 _description,
17282 _buffers,
17283 _metadata_buffer,
17284 _metadata,
17285 _signature_defs);
17286}
17287
17288inline bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type) {
17289 switch (type) {
17291 return true;
17292 }
17294 auto ptr = reinterpret_cast<const tflite::CustomQuantization *>(obj);
17295 return verifier.VerifyTable(ptr);
17296 }
17297 default: return true;
17298 }
17299}
17300
17301inline bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
17302 if (!values || !types) return !values && !types;
17303 if (values->size() != types->size()) return false;
17304 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
17306 verifier, values->Get(i), types->GetEnum<QuantizationDetails>(i))) {
17307 return false;
17308 }
17309 }
17310 return true;
17311}
17312
17314 (void)resolver;
17315 switch (type) {
17317 auto ptr = reinterpret_cast<const tflite::CustomQuantization *>(obj);
17318 return ptr->UnPack(resolver);
17319 }
17320 default: return nullptr;
17321 }
17322}
17323
17324inline flatbuffers::Offset<void> QuantizationDetailsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
17325 (void)_rehasher;
17326 switch (type) {
17328 auto ptr = reinterpret_cast<const tflite::CustomQuantizationT *>(value);
17329 return CreateCustomQuantization(_fbb, ptr, _rehasher).Union();
17330 }
17331 default: return 0;
17332 }
17333}
17334
17336 switch (type) {
17339 break;
17340 }
17341 default:
17342 break;
17343 }
17344}
17345
17347 switch (type) {
17349 auto ptr = reinterpret_cast<tflite::CustomQuantizationT *>(value);
17350 delete ptr;
17351 break;
17352 }
17353 default: break;
17354 }
17355 value = nullptr;
17357}
17358
17359inline bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type) {
17360 switch (type) {
17362 return true;
17363 }
17365 auto ptr = reinterpret_cast<const tflite::Int32Vector *>(obj);
17366 return verifier.VerifyTable(ptr);
17367 }
17369 auto ptr = reinterpret_cast<const tflite::Uint16Vector *>(obj);
17370 return verifier.VerifyTable(ptr);
17371 }
17373 auto ptr = reinterpret_cast<const tflite::Uint8Vector *>(obj);
17374 return verifier.VerifyTable(ptr);
17375 }
17376 default: return true;
17377 }
17378}
17379
17380inline bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
17381 if (!values || !types) return !values && !types;
17382 if (values->size() != types->size()) return false;
17383 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
17385 verifier, values->Get(i), types->GetEnum<SparseIndexVector>(i))) {
17386 return false;
17387 }
17388 }
17389 return true;
17390}
17391
17393 (void)resolver;
17394 switch (type) {
17396 auto ptr = reinterpret_cast<const tflite::Int32Vector *>(obj);
17397 return ptr->UnPack(resolver);
17398 }
17400 auto ptr = reinterpret_cast<const tflite::Uint16Vector *>(obj);
17401 return ptr->UnPack(resolver);
17402 }
17404 auto ptr = reinterpret_cast<const tflite::Uint8Vector *>(obj);
17405 return ptr->UnPack(resolver);
17406 }
17407 default: return nullptr;
17408 }
17409}
17410
17411inline flatbuffers::Offset<void> SparseIndexVectorUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
17412 (void)_rehasher;
17413 switch (type) {
17415 auto ptr = reinterpret_cast<const tflite::Int32VectorT *>(value);
17416 return CreateInt32Vector(_fbb, ptr, _rehasher).Union();
17417 }
17419 auto ptr = reinterpret_cast<const tflite::Uint16VectorT *>(value);
17420 return CreateUint16Vector(_fbb, ptr, _rehasher).Union();
17421 }
17423 auto ptr = reinterpret_cast<const tflite::Uint8VectorT *>(value);
17424 return CreateUint8Vector(_fbb, ptr, _rehasher).Union();
17425 }
17426 default: return 0;
17427 }
17428}
17429
17431 switch (type) {
17433 value = new tflite::Int32VectorT(*reinterpret_cast<tflite::Int32VectorT *>(u.value));
17434 break;
17435 }
17437 value = new tflite::Uint16VectorT(*reinterpret_cast<tflite::Uint16VectorT *>(u.value));
17438 break;
17439 }
17441 value = new tflite::Uint8VectorT(*reinterpret_cast<tflite::Uint8VectorT *>(u.value));
17442 break;
17443 }
17444 default:
17445 break;
17446 }
17447}
17448
17450 switch (type) {
17452 auto ptr = reinterpret_cast<tflite::Int32VectorT *>(value);
17453 delete ptr;
17454 break;
17455 }
17457 auto ptr = reinterpret_cast<tflite::Uint16VectorT *>(value);
17458 delete ptr;
17459 break;
17460 }
17462 auto ptr = reinterpret_cast<tflite::Uint8VectorT *>(value);
17463 delete ptr;
17464 break;
17465 }
17466 default: break;
17467 }
17468 value = nullptr;
17470}
17471
17472inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type) {
17473 switch (type) {
17474 case BuiltinOptions_NONE: {
17475 return true;
17476 }
17478 auto ptr = reinterpret_cast<const tflite::Conv2DOptions *>(obj);
17479 return verifier.VerifyTable(ptr);
17480 }
17482 auto ptr = reinterpret_cast<const tflite::DepthwiseConv2DOptions *>(obj);
17483 return verifier.VerifyTable(ptr);
17484 }
17486 auto ptr = reinterpret_cast<const tflite::ConcatEmbeddingsOptions *>(obj);
17487 return verifier.VerifyTable(ptr);
17488 }
17490 auto ptr = reinterpret_cast<const tflite::LSHProjectionOptions *>(obj);
17491 return verifier.VerifyTable(ptr);
17492 }
17494 auto ptr = reinterpret_cast<const tflite::Pool2DOptions *>(obj);
17495 return verifier.VerifyTable(ptr);
17496 }
17498 auto ptr = reinterpret_cast<const tflite::SVDFOptions *>(obj);
17499 return verifier.VerifyTable(ptr);
17500 }
17502 auto ptr = reinterpret_cast<const tflite::RNNOptions *>(obj);
17503 return verifier.VerifyTable(ptr);
17504 }
17506 auto ptr = reinterpret_cast<const tflite::FullyConnectedOptions *>(obj);
17507 return verifier.VerifyTable(ptr);
17508 }
17510 auto ptr = reinterpret_cast<const tflite::SoftmaxOptions *>(obj);
17511 return verifier.VerifyTable(ptr);
17512 }
17514 auto ptr = reinterpret_cast<const tflite::ConcatenationOptions *>(obj);
17515 return verifier.VerifyTable(ptr);
17516 }
17518 auto ptr = reinterpret_cast<const tflite::AddOptions *>(obj);
17519 return verifier.VerifyTable(ptr);
17520 }
17522 auto ptr = reinterpret_cast<const tflite::L2NormOptions *>(obj);
17523 return verifier.VerifyTable(ptr);
17524 }
17526 auto ptr = reinterpret_cast<const tflite::LocalResponseNormalizationOptions *>(obj);
17527 return verifier.VerifyTable(ptr);
17528 }
17530 auto ptr = reinterpret_cast<const tflite::LSTMOptions *>(obj);
17531 return verifier.VerifyTable(ptr);
17532 }
17534 auto ptr = reinterpret_cast<const tflite::ResizeBilinearOptions *>(obj);
17535 return verifier.VerifyTable(ptr);
17536 }
17538 auto ptr = reinterpret_cast<const tflite::CallOptions *>(obj);
17539 return verifier.VerifyTable(ptr);
17540 }
17542 auto ptr = reinterpret_cast<const tflite::ReshapeOptions *>(obj);
17543 return verifier.VerifyTable(ptr);
17544 }
17546 auto ptr = reinterpret_cast<const tflite::SkipGramOptions *>(obj);
17547 return verifier.VerifyTable(ptr);
17548 }
17550 auto ptr = reinterpret_cast<const tflite::SpaceToDepthOptions *>(obj);
17551 return verifier.VerifyTable(ptr);
17552 }
17554 auto ptr = reinterpret_cast<const tflite::EmbeddingLookupSparseOptions *>(obj);
17555 return verifier.VerifyTable(ptr);
17556 }
17558 auto ptr = reinterpret_cast<const tflite::MulOptions *>(obj);
17559 return verifier.VerifyTable(ptr);
17560 }
17562 auto ptr = reinterpret_cast<const tflite::PadOptions *>(obj);
17563 return verifier.VerifyTable(ptr);
17564 }
17566 auto ptr = reinterpret_cast<const tflite::GatherOptions *>(obj);
17567 return verifier.VerifyTable(ptr);
17568 }
17570 auto ptr = reinterpret_cast<const tflite::BatchToSpaceNDOptions *>(obj);
17571 return verifier.VerifyTable(ptr);
17572 }
17574 auto ptr = reinterpret_cast<const tflite::SpaceToBatchNDOptions *>(obj);
17575 return verifier.VerifyTable(ptr);
17576 }
17578 auto ptr = reinterpret_cast<const tflite::TransposeOptions *>(obj);
17579 return verifier.VerifyTable(ptr);
17580 }
17582 auto ptr = reinterpret_cast<const tflite::ReducerOptions *>(obj);
17583 return verifier.VerifyTable(ptr);
17584 }
17586 auto ptr = reinterpret_cast<const tflite::SubOptions *>(obj);
17587 return verifier.VerifyTable(ptr);
17588 }
17590 auto ptr = reinterpret_cast<const tflite::DivOptions *>(obj);
17591 return verifier.VerifyTable(ptr);
17592 }
17594 auto ptr = reinterpret_cast<const tflite::SqueezeOptions *>(obj);
17595 return verifier.VerifyTable(ptr);
17596 }
17598 auto ptr = reinterpret_cast<const tflite::SequenceRNNOptions *>(obj);
17599 return verifier.VerifyTable(ptr);
17600 }
17602 auto ptr = reinterpret_cast<const tflite::StridedSliceOptions *>(obj);
17603 return verifier.VerifyTable(ptr);
17604 }
17606 auto ptr = reinterpret_cast<const tflite::ExpOptions *>(obj);
17607 return verifier.VerifyTable(ptr);
17608 }
17610 auto ptr = reinterpret_cast<const tflite::TopKV2Options *>(obj);
17611 return verifier.VerifyTable(ptr);
17612 }
17614 auto ptr = reinterpret_cast<const tflite::SplitOptions *>(obj);
17615 return verifier.VerifyTable(ptr);
17616 }
17618 auto ptr = reinterpret_cast<const tflite::LogSoftmaxOptions *>(obj);
17619 return verifier.VerifyTable(ptr);
17620 }
17622 auto ptr = reinterpret_cast<const tflite::CastOptions *>(obj);
17623 return verifier.VerifyTable(ptr);
17624 }
17626 auto ptr = reinterpret_cast<const tflite::DequantizeOptions *>(obj);
17627 return verifier.VerifyTable(ptr);
17628 }
17630 auto ptr = reinterpret_cast<const tflite::MaximumMinimumOptions *>(obj);
17631 return verifier.VerifyTable(ptr);
17632 }
17634 auto ptr = reinterpret_cast<const tflite::ArgMaxOptions *>(obj);
17635 return verifier.VerifyTable(ptr);
17636 }
17638 auto ptr = reinterpret_cast<const tflite::LessOptions *>(obj);
17639 return verifier.VerifyTable(ptr);
17640 }
17642 auto ptr = reinterpret_cast<const tflite::NegOptions *>(obj);
17643 return verifier.VerifyTable(ptr);
17644 }
17646 auto ptr = reinterpret_cast<const tflite::PadV2Options *>(obj);
17647 return verifier.VerifyTable(ptr);
17648 }
17650 auto ptr = reinterpret_cast<const tflite::GreaterOptions *>(obj);
17651 return verifier.VerifyTable(ptr);
17652 }
17654 auto ptr = reinterpret_cast<const tflite::GreaterEqualOptions *>(obj);
17655 return verifier.VerifyTable(ptr);
17656 }
17658 auto ptr = reinterpret_cast<const tflite::LessEqualOptions *>(obj);
17659 return verifier.VerifyTable(ptr);
17660 }
17662 auto ptr = reinterpret_cast<const tflite::SelectOptions *>(obj);
17663 return verifier.VerifyTable(ptr);
17664 }
17666 auto ptr = reinterpret_cast<const tflite::SliceOptions *>(obj);
17667 return verifier.VerifyTable(ptr);
17668 }
17670 auto ptr = reinterpret_cast<const tflite::TransposeConvOptions *>(obj);
17671 return verifier.VerifyTable(ptr);
17672 }
17674 auto ptr = reinterpret_cast<const tflite::SparseToDenseOptions *>(obj);
17675 return verifier.VerifyTable(ptr);
17676 }
17678 auto ptr = reinterpret_cast<const tflite::TileOptions *>(obj);
17679 return verifier.VerifyTable(ptr);
17680 }
17682 auto ptr = reinterpret_cast<const tflite::ExpandDimsOptions *>(obj);
17683 return verifier.VerifyTable(ptr);
17684 }
17686 auto ptr = reinterpret_cast<const tflite::EqualOptions *>(obj);
17687 return verifier.VerifyTable(ptr);
17688 }
17690 auto ptr = reinterpret_cast<const tflite::NotEqualOptions *>(obj);
17691 return verifier.VerifyTable(ptr);
17692 }
17694 auto ptr = reinterpret_cast<const tflite::ShapeOptions *>(obj);
17695 return verifier.VerifyTable(ptr);
17696 }
17698 auto ptr = reinterpret_cast<const tflite::PowOptions *>(obj);
17699 return verifier.VerifyTable(ptr);
17700 }
17702 auto ptr = reinterpret_cast<const tflite::ArgMinOptions *>(obj);
17703 return verifier.VerifyTable(ptr);
17704 }
17706 auto ptr = reinterpret_cast<const tflite::FakeQuantOptions *>(obj);
17707 return verifier.VerifyTable(ptr);
17708 }
17710 auto ptr = reinterpret_cast<const tflite::PackOptions *>(obj);
17711 return verifier.VerifyTable(ptr);
17712 }
17714 auto ptr = reinterpret_cast<const tflite::LogicalOrOptions *>(obj);
17715 return verifier.VerifyTable(ptr);
17716 }
17718 auto ptr = reinterpret_cast<const tflite::OneHotOptions *>(obj);
17719 return verifier.VerifyTable(ptr);
17720 }
17722 auto ptr = reinterpret_cast<const tflite::LogicalAndOptions *>(obj);
17723 return verifier.VerifyTable(ptr);
17724 }
17726 auto ptr = reinterpret_cast<const tflite::LogicalNotOptions *>(obj);
17727 return verifier.VerifyTable(ptr);
17728 }
17730 auto ptr = reinterpret_cast<const tflite::UnpackOptions *>(obj);
17731 return verifier.VerifyTable(ptr);
17732 }
17734 auto ptr = reinterpret_cast<const tflite::FloorDivOptions *>(obj);
17735 return verifier.VerifyTable(ptr);
17736 }
17738 auto ptr = reinterpret_cast<const tflite::SquareOptions *>(obj);
17739 return verifier.VerifyTable(ptr);
17740 }
17742 auto ptr = reinterpret_cast<const tflite::ZerosLikeOptions *>(obj);
17743 return verifier.VerifyTable(ptr);
17744 }
17746 auto ptr = reinterpret_cast<const tflite::FillOptions *>(obj);
17747 return verifier.VerifyTable(ptr);
17748 }
17750 auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptions *>(obj);
17751 return verifier.VerifyTable(ptr);
17752 }
17754 auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceRNNOptions *>(obj);
17755 return verifier.VerifyTable(ptr);
17756 }
17758 auto ptr = reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptions *>(obj);
17759 return verifier.VerifyTable(ptr);
17760 }
17762 auto ptr = reinterpret_cast<const tflite::FloorModOptions *>(obj);
17763 return verifier.VerifyTable(ptr);
17764 }
17766 auto ptr = reinterpret_cast<const tflite::RangeOptions *>(obj);
17767 return verifier.VerifyTable(ptr);
17768 }
17770 auto ptr = reinterpret_cast<const tflite::ResizeNearestNeighborOptions *>(obj);
17771 return verifier.VerifyTable(ptr);
17772 }
17774 auto ptr = reinterpret_cast<const tflite::LeakyReluOptions *>(obj);
17775 return verifier.VerifyTable(ptr);
17776 }
17778 auto ptr = reinterpret_cast<const tflite::SquaredDifferenceOptions *>(obj);
17779 return verifier.VerifyTable(ptr);
17780 }
17782 auto ptr = reinterpret_cast<const tflite::MirrorPadOptions *>(obj);
17783 return verifier.VerifyTable(ptr);
17784 }
17786 auto ptr = reinterpret_cast<const tflite::AbsOptions *>(obj);
17787 return verifier.VerifyTable(ptr);
17788 }
17790 auto ptr = reinterpret_cast<const tflite::SplitVOptions *>(obj);
17791 return verifier.VerifyTable(ptr);
17792 }
17794 auto ptr = reinterpret_cast<const tflite::UniqueOptions *>(obj);
17795 return verifier.VerifyTable(ptr);
17796 }
17798 auto ptr = reinterpret_cast<const tflite::ReverseV2Options *>(obj);
17799 return verifier.VerifyTable(ptr);
17800 }
17802 auto ptr = reinterpret_cast<const tflite::AddNOptions *>(obj);
17803 return verifier.VerifyTable(ptr);
17804 }
17806 auto ptr = reinterpret_cast<const tflite::GatherNdOptions *>(obj);
17807 return verifier.VerifyTable(ptr);
17808 }
17810 auto ptr = reinterpret_cast<const tflite::CosOptions *>(obj);
17811 return verifier.VerifyTable(ptr);
17812 }
17814 auto ptr = reinterpret_cast<const tflite::WhereOptions *>(obj);
17815 return verifier.VerifyTable(ptr);
17816 }
17818 auto ptr = reinterpret_cast<const tflite::RankOptions *>(obj);
17819 return verifier.VerifyTable(ptr);
17820 }
17822 auto ptr = reinterpret_cast<const tflite::ReverseSequenceOptions *>(obj);
17823 return verifier.VerifyTable(ptr);
17824 }
17826 auto ptr = reinterpret_cast<const tflite::MatrixDiagOptions *>(obj);
17827 return verifier.VerifyTable(ptr);
17828 }
17830 auto ptr = reinterpret_cast<const tflite::QuantizeOptions *>(obj);
17831 return verifier.VerifyTable(ptr);
17832 }
17834 auto ptr = reinterpret_cast<const tflite::MatrixSetDiagOptions *>(obj);
17835 return verifier.VerifyTable(ptr);
17836 }
17838 auto ptr = reinterpret_cast<const tflite::HardSwishOptions *>(obj);
17839 return verifier.VerifyTable(ptr);
17840 }
17842 auto ptr = reinterpret_cast<const tflite::IfOptions *>(obj);
17843 return verifier.VerifyTable(ptr);
17844 }
17846 auto ptr = reinterpret_cast<const tflite::WhileOptions *>(obj);
17847 return verifier.VerifyTable(ptr);
17848 }
17850 auto ptr = reinterpret_cast<const tflite::DepthToSpaceOptions *>(obj);
17851 return verifier.VerifyTable(ptr);
17852 }
17854 auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV4Options *>(obj);
17855 return verifier.VerifyTable(ptr);
17856 }
17858 auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV5Options *>(obj);
17859 return verifier.VerifyTable(ptr);
17860 }
17862 auto ptr = reinterpret_cast<const tflite::ScatterNdOptions *>(obj);
17863 return verifier.VerifyTable(ptr);
17864 }
17866 auto ptr = reinterpret_cast<const tflite::SelectV2Options *>(obj);
17867 return verifier.VerifyTable(ptr);
17868 }
17870 auto ptr = reinterpret_cast<const tflite::DensifyOptions *>(obj);
17871 return verifier.VerifyTable(ptr);
17872 }
17874 auto ptr = reinterpret_cast<const tflite::SegmentSumOptions *>(obj);
17875 return verifier.VerifyTable(ptr);
17876 }
17878 auto ptr = reinterpret_cast<const tflite::BatchMatMulOptions *>(obj);
17879 return verifier.VerifyTable(ptr);
17880 }
17882 auto ptr = reinterpret_cast<const tflite::CumsumOptions *>(obj);
17883 return verifier.VerifyTable(ptr);
17884 }
17886 auto ptr = reinterpret_cast<const tflite::CallOnceOptions *>(obj);
17887 return verifier.VerifyTable(ptr);
17888 }
17890 auto ptr = reinterpret_cast<const tflite::BroadcastToOptions *>(obj);
17891 return verifier.VerifyTable(ptr);
17892 }
17894 auto ptr = reinterpret_cast<const tflite::Rfft2dOptions *>(obj);
17895 return verifier.VerifyTable(ptr);
17896 }
17898 auto ptr = reinterpret_cast<const tflite::Conv3DOptions *>(obj);
17899 return verifier.VerifyTable(ptr);
17900 }
17902 auto ptr = reinterpret_cast<const tflite::HashtableOptions *>(obj);
17903 return verifier.VerifyTable(ptr);
17904 }
17906 auto ptr = reinterpret_cast<const tflite::HashtableFindOptions *>(obj);
17907 return verifier.VerifyTable(ptr);
17908 }
17910 auto ptr = reinterpret_cast<const tflite::HashtableImportOptions *>(obj);
17911 return verifier.VerifyTable(ptr);
17912 }
17914 auto ptr = reinterpret_cast<const tflite::HashtableSizeOptions *>(obj);
17915 return verifier.VerifyTable(ptr);
17916 }
17918 auto ptr = reinterpret_cast<const tflite::VarHandleOptions *>(obj);
17919 return verifier.VerifyTable(ptr);
17920 }
17922 auto ptr = reinterpret_cast<const tflite::ReadVariableOptions *>(obj);
17923 return verifier.VerifyTable(ptr);
17924 }
17926 auto ptr = reinterpret_cast<const tflite::AssignVariableOptions *>(obj);
17927 return verifier.VerifyTable(ptr);
17928 }
17930 auto ptr = reinterpret_cast<const tflite::RandomOptions *>(obj);
17931 return verifier.VerifyTable(ptr);
17932 }
17934 auto ptr = reinterpret_cast<const tflite::BucketizeOptions *>(obj);
17935 return verifier.VerifyTable(ptr);
17936 }
17938 auto ptr = reinterpret_cast<const tflite::GeluOptions *>(obj);
17939 return verifier.VerifyTable(ptr);
17940 }
17942 auto ptr = reinterpret_cast<const tflite::DynamicUpdateSliceOptions *>(obj);
17943 return verifier.VerifyTable(ptr);
17944 }
17946 auto ptr = reinterpret_cast<const tflite::UnsortedSegmentProdOptions *>(obj);
17947 return verifier.VerifyTable(ptr);
17948 }
17950 auto ptr = reinterpret_cast<const tflite::UnsortedSegmentMaxOptions *>(obj);
17951 return verifier.VerifyTable(ptr);
17952 }
17954 auto ptr = reinterpret_cast<const tflite::UnsortedSegmentMinOptions *>(obj);
17955 return verifier.VerifyTable(ptr);
17956 }
17958 auto ptr = reinterpret_cast<const tflite::UnsortedSegmentSumOptions *>(obj);
17959 return verifier.VerifyTable(ptr);
17960 }
17962 auto ptr = reinterpret_cast<const tflite::ATan2Options *>(obj);
17963 return verifier.VerifyTable(ptr);
17964 }
17966 auto ptr = reinterpret_cast<const tflite::SignOptions *>(obj);
17967 return verifier.VerifyTable(ptr);
17968 }
17969 default: return true;
17970 }
17971}
17972
17973inline bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
17974 if (!values || !types) return !values && !types;
17975 if (values->size() != types->size()) return false;
17976 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
17978 verifier, values->Get(i), types->GetEnum<BuiltinOptions>(i))) {
17979 return false;
17980 }
17981 }
17982 return true;
17983}
17984
17986 (void)resolver;
17987 switch (type) {
17989 auto ptr = reinterpret_cast<const tflite::Conv2DOptions *>(obj);
17990 return ptr->UnPack(resolver);
17991 }
17993 auto ptr = reinterpret_cast<const tflite::DepthwiseConv2DOptions *>(obj);
17994 return ptr->UnPack(resolver);
17995 }
17997 auto ptr = reinterpret_cast<const tflite::ConcatEmbeddingsOptions *>(obj);
17998 return ptr->UnPack(resolver);
17999 }
18001 auto ptr = reinterpret_cast<const tflite::LSHProjectionOptions *>(obj);
18002 return ptr->UnPack(resolver);
18003 }
18005 auto ptr = reinterpret_cast<const tflite::Pool2DOptions *>(obj);
18006 return ptr->UnPack(resolver);
18007 }
18009 auto ptr = reinterpret_cast<const tflite::SVDFOptions *>(obj);
18010 return ptr->UnPack(resolver);
18011 }
18013 auto ptr = reinterpret_cast<const tflite::RNNOptions *>(obj);
18014 return ptr->UnPack(resolver);
18015 }
18017 auto ptr = reinterpret_cast<const tflite::FullyConnectedOptions *>(obj);
18018 return ptr->UnPack(resolver);
18019 }
18021 auto ptr = reinterpret_cast<const tflite::SoftmaxOptions *>(obj);
18022 return ptr->UnPack(resolver);
18023 }
18025 auto ptr = reinterpret_cast<const tflite::ConcatenationOptions *>(obj);
18026 return ptr->UnPack(resolver);
18027 }
18029 auto ptr = reinterpret_cast<const tflite::AddOptions *>(obj);
18030 return ptr->UnPack(resolver);
18031 }
18033 auto ptr = reinterpret_cast<const tflite::L2NormOptions *>(obj);
18034 return ptr->UnPack(resolver);
18035 }
18037 auto ptr = reinterpret_cast<const tflite::LocalResponseNormalizationOptions *>(obj);
18038 return ptr->UnPack(resolver);
18039 }
18041 auto ptr = reinterpret_cast<const tflite::LSTMOptions *>(obj);
18042 return ptr->UnPack(resolver);
18043 }
18045 auto ptr = reinterpret_cast<const tflite::ResizeBilinearOptions *>(obj);
18046 return ptr->UnPack(resolver);
18047 }
18049 auto ptr = reinterpret_cast<const tflite::CallOptions *>(obj);
18050 return ptr->UnPack(resolver);
18051 }
18053 auto ptr = reinterpret_cast<const tflite::ReshapeOptions *>(obj);
18054 return ptr->UnPack(resolver);
18055 }
18057 auto ptr = reinterpret_cast<const tflite::SkipGramOptions *>(obj);
18058 return ptr->UnPack(resolver);
18059 }
18061 auto ptr = reinterpret_cast<const tflite::SpaceToDepthOptions *>(obj);
18062 return ptr->UnPack(resolver);
18063 }
18065 auto ptr = reinterpret_cast<const tflite::EmbeddingLookupSparseOptions *>(obj);
18066 return ptr->UnPack(resolver);
18067 }
18069 auto ptr = reinterpret_cast<const tflite::MulOptions *>(obj);
18070 return ptr->UnPack(resolver);
18071 }
18073 auto ptr = reinterpret_cast<const tflite::PadOptions *>(obj);
18074 return ptr->UnPack(resolver);
18075 }
18077 auto ptr = reinterpret_cast<const tflite::GatherOptions *>(obj);
18078 return ptr->UnPack(resolver);
18079 }
18081 auto ptr = reinterpret_cast<const tflite::BatchToSpaceNDOptions *>(obj);
18082 return ptr->UnPack(resolver);
18083 }
18085 auto ptr = reinterpret_cast<const tflite::SpaceToBatchNDOptions *>(obj);
18086 return ptr->UnPack(resolver);
18087 }
18089 auto ptr = reinterpret_cast<const tflite::TransposeOptions *>(obj);
18090 return ptr->UnPack(resolver);
18091 }
18093 auto ptr = reinterpret_cast<const tflite::ReducerOptions *>(obj);
18094 return ptr->UnPack(resolver);
18095 }
18097 auto ptr = reinterpret_cast<const tflite::SubOptions *>(obj);
18098 return ptr->UnPack(resolver);
18099 }
18101 auto ptr = reinterpret_cast<const tflite::DivOptions *>(obj);
18102 return ptr->UnPack(resolver);
18103 }
18105 auto ptr = reinterpret_cast<const tflite::SqueezeOptions *>(obj);
18106 return ptr->UnPack(resolver);
18107 }
18109 auto ptr = reinterpret_cast<const tflite::SequenceRNNOptions *>(obj);
18110 return ptr->UnPack(resolver);
18111 }
18113 auto ptr = reinterpret_cast<const tflite::StridedSliceOptions *>(obj);
18114 return ptr->UnPack(resolver);
18115 }
18117 auto ptr = reinterpret_cast<const tflite::ExpOptions *>(obj);
18118 return ptr->UnPack(resolver);
18119 }
18121 auto ptr = reinterpret_cast<const tflite::TopKV2Options *>(obj);
18122 return ptr->UnPack(resolver);
18123 }
18125 auto ptr = reinterpret_cast<const tflite::SplitOptions *>(obj);
18126 return ptr->UnPack(resolver);
18127 }
18129 auto ptr = reinterpret_cast<const tflite::LogSoftmaxOptions *>(obj);
18130 return ptr->UnPack(resolver);
18131 }
18133 auto ptr = reinterpret_cast<const tflite::CastOptions *>(obj);
18134 return ptr->UnPack(resolver);
18135 }
18137 auto ptr = reinterpret_cast<const tflite::DequantizeOptions *>(obj);
18138 return ptr->UnPack(resolver);
18139 }
18141 auto ptr = reinterpret_cast<const tflite::MaximumMinimumOptions *>(obj);
18142 return ptr->UnPack(resolver);
18143 }
18145 auto ptr = reinterpret_cast<const tflite::ArgMaxOptions *>(obj);
18146 return ptr->UnPack(resolver);
18147 }
18149 auto ptr = reinterpret_cast<const tflite::LessOptions *>(obj);
18150 return ptr->UnPack(resolver);
18151 }
18153 auto ptr = reinterpret_cast<const tflite::NegOptions *>(obj);
18154 return ptr->UnPack(resolver);
18155 }
18157 auto ptr = reinterpret_cast<const tflite::PadV2Options *>(obj);
18158 return ptr->UnPack(resolver);
18159 }
18161 auto ptr = reinterpret_cast<const tflite::GreaterOptions *>(obj);
18162 return ptr->UnPack(resolver);
18163 }
18165 auto ptr = reinterpret_cast<const tflite::GreaterEqualOptions *>(obj);
18166 return ptr->UnPack(resolver);
18167 }
18169 auto ptr = reinterpret_cast<const tflite::LessEqualOptions *>(obj);
18170 return ptr->UnPack(resolver);
18171 }
18173 auto ptr = reinterpret_cast<const tflite::SelectOptions *>(obj);
18174 return ptr->UnPack(resolver);
18175 }
18177 auto ptr = reinterpret_cast<const tflite::SliceOptions *>(obj);
18178 return ptr->UnPack(resolver);
18179 }
18181 auto ptr = reinterpret_cast<const tflite::TransposeConvOptions *>(obj);
18182 return ptr->UnPack(resolver);
18183 }
18185 auto ptr = reinterpret_cast<const tflite::SparseToDenseOptions *>(obj);
18186 return ptr->UnPack(resolver);
18187 }
18189 auto ptr = reinterpret_cast<const tflite::TileOptions *>(obj);
18190 return ptr->UnPack(resolver);
18191 }
18193 auto ptr = reinterpret_cast<const tflite::ExpandDimsOptions *>(obj);
18194 return ptr->UnPack(resolver);
18195 }
18197 auto ptr = reinterpret_cast<const tflite::EqualOptions *>(obj);
18198 return ptr->UnPack(resolver);
18199 }
18201 auto ptr = reinterpret_cast<const tflite::NotEqualOptions *>(obj);
18202 return ptr->UnPack(resolver);
18203 }
18205 auto ptr = reinterpret_cast<const tflite::ShapeOptions *>(obj);
18206 return ptr->UnPack(resolver);
18207 }
18209 auto ptr = reinterpret_cast<const tflite::PowOptions *>(obj);
18210 return ptr->UnPack(resolver);
18211 }
18213 auto ptr = reinterpret_cast<const tflite::ArgMinOptions *>(obj);
18214 return ptr->UnPack(resolver);
18215 }
18217 auto ptr = reinterpret_cast<const tflite::FakeQuantOptions *>(obj);
18218 return ptr->UnPack(resolver);
18219 }
18221 auto ptr = reinterpret_cast<const tflite::PackOptions *>(obj);
18222 return ptr->UnPack(resolver);
18223 }
18225 auto ptr = reinterpret_cast<const tflite::LogicalOrOptions *>(obj);
18226 return ptr->UnPack(resolver);
18227 }
18229 auto ptr = reinterpret_cast<const tflite::OneHotOptions *>(obj);
18230 return ptr->UnPack(resolver);
18231 }
18233 auto ptr = reinterpret_cast<const tflite::LogicalAndOptions *>(obj);
18234 return ptr->UnPack(resolver);
18235 }
18237 auto ptr = reinterpret_cast<const tflite::LogicalNotOptions *>(obj);
18238 return ptr->UnPack(resolver);
18239 }
18241 auto ptr = reinterpret_cast<const tflite::UnpackOptions *>(obj);
18242 return ptr->UnPack(resolver);
18243 }
18245 auto ptr = reinterpret_cast<const tflite::FloorDivOptions *>(obj);
18246 return ptr->UnPack(resolver);
18247 }
18249 auto ptr = reinterpret_cast<const tflite::SquareOptions *>(obj);
18250 return ptr->UnPack(resolver);
18251 }
18253 auto ptr = reinterpret_cast<const tflite::ZerosLikeOptions *>(obj);
18254 return ptr->UnPack(resolver);
18255 }
18257 auto ptr = reinterpret_cast<const tflite::FillOptions *>(obj);
18258 return ptr->UnPack(resolver);
18259 }
18261 auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptions *>(obj);
18262 return ptr->UnPack(resolver);
18263 }
18265 auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceRNNOptions *>(obj);
18266 return ptr->UnPack(resolver);
18267 }
18269 auto ptr = reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptions *>(obj);
18270 return ptr->UnPack(resolver);
18271 }
18273 auto ptr = reinterpret_cast<const tflite::FloorModOptions *>(obj);
18274 return ptr->UnPack(resolver);
18275 }
18277 auto ptr = reinterpret_cast<const tflite::RangeOptions *>(obj);
18278 return ptr->UnPack(resolver);
18279 }
18281 auto ptr = reinterpret_cast<const tflite::ResizeNearestNeighborOptions *>(obj);
18282 return ptr->UnPack(resolver);
18283 }
18285 auto ptr = reinterpret_cast<const tflite::LeakyReluOptions *>(obj);
18286 return ptr->UnPack(resolver);
18287 }
18289 auto ptr = reinterpret_cast<const tflite::SquaredDifferenceOptions *>(obj);
18290 return ptr->UnPack(resolver);
18291 }
18293 auto ptr = reinterpret_cast<const tflite::MirrorPadOptions *>(obj);
18294 return ptr->UnPack(resolver);
18295 }
18297 auto ptr = reinterpret_cast<const tflite::AbsOptions *>(obj);
18298 return ptr->UnPack(resolver);
18299 }
18301 auto ptr = reinterpret_cast<const tflite::SplitVOptions *>(obj);
18302 return ptr->UnPack(resolver);
18303 }
18305 auto ptr = reinterpret_cast<const tflite::UniqueOptions *>(obj);
18306 return ptr->UnPack(resolver);
18307 }
18309 auto ptr = reinterpret_cast<const tflite::ReverseV2Options *>(obj);
18310 return ptr->UnPack(resolver);
18311 }
18313 auto ptr = reinterpret_cast<const tflite::AddNOptions *>(obj);
18314 return ptr->UnPack(resolver);
18315 }
18317 auto ptr = reinterpret_cast<const tflite::GatherNdOptions *>(obj);
18318 return ptr->UnPack(resolver);
18319 }
18321 auto ptr = reinterpret_cast<const tflite::CosOptions *>(obj);
18322 return ptr->UnPack(resolver);
18323 }
18325 auto ptr = reinterpret_cast<const tflite::WhereOptions *>(obj);
18326 return ptr->UnPack(resolver);
18327 }
18329 auto ptr = reinterpret_cast<const tflite::RankOptions *>(obj);
18330 return ptr->UnPack(resolver);
18331 }
18333 auto ptr = reinterpret_cast<const tflite::ReverseSequenceOptions *>(obj);
18334 return ptr->UnPack(resolver);
18335 }
18337 auto ptr = reinterpret_cast<const tflite::MatrixDiagOptions *>(obj);
18338 return ptr->UnPack(resolver);
18339 }
18341 auto ptr = reinterpret_cast<const tflite::QuantizeOptions *>(obj);
18342 return ptr->UnPack(resolver);
18343 }
18345 auto ptr = reinterpret_cast<const tflite::MatrixSetDiagOptions *>(obj);
18346 return ptr->UnPack(resolver);
18347 }
18349 auto ptr = reinterpret_cast<const tflite::HardSwishOptions *>(obj);
18350 return ptr->UnPack(resolver);
18351 }
18353 auto ptr = reinterpret_cast<const tflite::IfOptions *>(obj);
18354 return ptr->UnPack(resolver);
18355 }
18357 auto ptr = reinterpret_cast<const tflite::WhileOptions *>(obj);
18358 return ptr->UnPack(resolver);
18359 }
18361 auto ptr = reinterpret_cast<const tflite::DepthToSpaceOptions *>(obj);
18362 return ptr->UnPack(resolver);
18363 }
18365 auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV4Options *>(obj);
18366 return ptr->UnPack(resolver);
18367 }
18369 auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV5Options *>(obj);
18370 return ptr->UnPack(resolver);
18371 }
18373 auto ptr = reinterpret_cast<const tflite::ScatterNdOptions *>(obj);
18374 return ptr->UnPack(resolver);
18375 }
18377 auto ptr = reinterpret_cast<const tflite::SelectV2Options *>(obj);
18378 return ptr->UnPack(resolver);
18379 }
18381 auto ptr = reinterpret_cast<const tflite::DensifyOptions *>(obj);
18382 return ptr->UnPack(resolver);
18383 }
18385 auto ptr = reinterpret_cast<const tflite::SegmentSumOptions *>(obj);
18386 return ptr->UnPack(resolver);
18387 }
18389 auto ptr = reinterpret_cast<const tflite::BatchMatMulOptions *>(obj);
18390 return ptr->UnPack(resolver);
18391 }
18393 auto ptr = reinterpret_cast<const tflite::CumsumOptions *>(obj);
18394 return ptr->UnPack(resolver);
18395 }
18397 auto ptr = reinterpret_cast<const tflite::CallOnceOptions *>(obj);
18398 return ptr->UnPack(resolver);
18399 }
18401 auto ptr = reinterpret_cast<const tflite::BroadcastToOptions *>(obj);
18402 return ptr->UnPack(resolver);
18403 }
18405 auto ptr = reinterpret_cast<const tflite::Rfft2dOptions *>(obj);
18406 return ptr->UnPack(resolver);
18407 }
18409 auto ptr = reinterpret_cast<const tflite::Conv3DOptions *>(obj);
18410 return ptr->UnPack(resolver);
18411 }
18413 auto ptr = reinterpret_cast<const tflite::HashtableOptions *>(obj);
18414 return ptr->UnPack(resolver);
18415 }
18417 auto ptr = reinterpret_cast<const tflite::HashtableFindOptions *>(obj);
18418 return ptr->UnPack(resolver);
18419 }
18421 auto ptr = reinterpret_cast<const tflite::HashtableImportOptions *>(obj);
18422 return ptr->UnPack(resolver);
18423 }
18425 auto ptr = reinterpret_cast<const tflite::HashtableSizeOptions *>(obj);
18426 return ptr->UnPack(resolver);
18427 }
18429 auto ptr = reinterpret_cast<const tflite::VarHandleOptions *>(obj);
18430 return ptr->UnPack(resolver);
18431 }
18433 auto ptr = reinterpret_cast<const tflite::ReadVariableOptions *>(obj);
18434 return ptr->UnPack(resolver);
18435 }
18437 auto ptr = reinterpret_cast<const tflite::AssignVariableOptions *>(obj);
18438 return ptr->UnPack(resolver);
18439 }
18441 auto ptr = reinterpret_cast<const tflite::RandomOptions *>(obj);
18442 return ptr->UnPack(resolver);
18443 }
18445 auto ptr = reinterpret_cast<const tflite::BucketizeOptions *>(obj);
18446 return ptr->UnPack(resolver);
18447 }
18449 auto ptr = reinterpret_cast<const tflite::GeluOptions *>(obj);
18450 return ptr->UnPack(resolver);
18451 }
18453 auto ptr = reinterpret_cast<const tflite::DynamicUpdateSliceOptions *>(obj);
18454 return ptr->UnPack(resolver);
18455 }
18457 auto ptr = reinterpret_cast<const tflite::UnsortedSegmentProdOptions *>(obj);
18458 return ptr->UnPack(resolver);
18459 }
18461 auto ptr = reinterpret_cast<const tflite::UnsortedSegmentMaxOptions *>(obj);
18462 return ptr->UnPack(resolver);
18463 }
18465 auto ptr = reinterpret_cast<const tflite::UnsortedSegmentMinOptions *>(obj);
18466 return ptr->UnPack(resolver);
18467 }
18469 auto ptr = reinterpret_cast<const tflite::UnsortedSegmentSumOptions *>(obj);
18470 return ptr->UnPack(resolver);
18471 }
18473 auto ptr = reinterpret_cast<const tflite::ATan2Options *>(obj);
18474 return ptr->UnPack(resolver);
18475 }
18477 auto ptr = reinterpret_cast<const tflite::SignOptions *>(obj);
18478 return ptr->UnPack(resolver);
18479 }
18480 default: return nullptr;
18481 }
18482}
18483
18484inline flatbuffers::Offset<void> BuiltinOptionsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
18485 (void)_rehasher;
18486 switch (type) {
18488 auto ptr = reinterpret_cast<const tflite::Conv2DOptionsT *>(value);
18489 return CreateConv2DOptions(_fbb, ptr, _rehasher).Union();
18490 }
18492 auto ptr = reinterpret_cast<const tflite::DepthwiseConv2DOptionsT *>(value);
18493 return CreateDepthwiseConv2DOptions(_fbb, ptr, _rehasher).Union();
18494 }
18496 auto ptr = reinterpret_cast<const tflite::ConcatEmbeddingsOptionsT *>(value);
18497 return CreateConcatEmbeddingsOptions(_fbb, ptr, _rehasher).Union();
18498 }
18500 auto ptr = reinterpret_cast<const tflite::LSHProjectionOptionsT *>(value);
18501 return CreateLSHProjectionOptions(_fbb, ptr, _rehasher).Union();
18502 }
18504 auto ptr = reinterpret_cast<const tflite::Pool2DOptionsT *>(value);
18505 return CreatePool2DOptions(_fbb, ptr, _rehasher).Union();
18506 }
18508 auto ptr = reinterpret_cast<const tflite::SVDFOptionsT *>(value);
18509 return CreateSVDFOptions(_fbb, ptr, _rehasher).Union();
18510 }
18512 auto ptr = reinterpret_cast<const tflite::RNNOptionsT *>(value);
18513 return CreateRNNOptions(_fbb, ptr, _rehasher).Union();
18514 }
18516 auto ptr = reinterpret_cast<const tflite::FullyConnectedOptionsT *>(value);
18517 return CreateFullyConnectedOptions(_fbb, ptr, _rehasher).Union();
18518 }
18520 auto ptr = reinterpret_cast<const tflite::SoftmaxOptionsT *>(value);
18521 return CreateSoftmaxOptions(_fbb, ptr, _rehasher).Union();
18522 }
18524 auto ptr = reinterpret_cast<const tflite::ConcatenationOptionsT *>(value);
18525 return CreateConcatenationOptions(_fbb, ptr, _rehasher).Union();
18526 }
18528 auto ptr = reinterpret_cast<const tflite::AddOptionsT *>(value);
18529 return CreateAddOptions(_fbb, ptr, _rehasher).Union();
18530 }
18532 auto ptr = reinterpret_cast<const tflite::L2NormOptionsT *>(value);
18533 return CreateL2NormOptions(_fbb, ptr, _rehasher).Union();
18534 }
18536 auto ptr = reinterpret_cast<const tflite::LocalResponseNormalizationOptionsT *>(value);
18537 return CreateLocalResponseNormalizationOptions(_fbb, ptr, _rehasher).Union();
18538 }
18540 auto ptr = reinterpret_cast<const tflite::LSTMOptionsT *>(value);
18541 return CreateLSTMOptions(_fbb, ptr, _rehasher).Union();
18542 }
18544 auto ptr = reinterpret_cast<const tflite::ResizeBilinearOptionsT *>(value);
18545 return CreateResizeBilinearOptions(_fbb, ptr, _rehasher).Union();
18546 }
18548 auto ptr = reinterpret_cast<const tflite::CallOptionsT *>(value);
18549 return CreateCallOptions(_fbb, ptr, _rehasher).Union();
18550 }
18552 auto ptr = reinterpret_cast<const tflite::ReshapeOptionsT *>(value);
18553 return CreateReshapeOptions(_fbb, ptr, _rehasher).Union();
18554 }
18556 auto ptr = reinterpret_cast<const tflite::SkipGramOptionsT *>(value);
18557 return CreateSkipGramOptions(_fbb, ptr, _rehasher).Union();
18558 }
18560 auto ptr = reinterpret_cast<const tflite::SpaceToDepthOptionsT *>(value);
18561 return CreateSpaceToDepthOptions(_fbb, ptr, _rehasher).Union();
18562 }
18564 auto ptr = reinterpret_cast<const tflite::EmbeddingLookupSparseOptionsT *>(value);
18565 return CreateEmbeddingLookupSparseOptions(_fbb, ptr, _rehasher).Union();
18566 }
18568 auto ptr = reinterpret_cast<const tflite::MulOptionsT *>(value);
18569 return CreateMulOptions(_fbb, ptr, _rehasher).Union();
18570 }
18572 auto ptr = reinterpret_cast<const tflite::PadOptionsT *>(value);
18573 return CreatePadOptions(_fbb, ptr, _rehasher).Union();
18574 }
18576 auto ptr = reinterpret_cast<const tflite::GatherOptionsT *>(value);
18577 return CreateGatherOptions(_fbb, ptr, _rehasher).Union();
18578 }
18580 auto ptr = reinterpret_cast<const tflite::BatchToSpaceNDOptionsT *>(value);
18581 return CreateBatchToSpaceNDOptions(_fbb, ptr, _rehasher).Union();
18582 }
18584 auto ptr = reinterpret_cast<const tflite::SpaceToBatchNDOptionsT *>(value);
18585 return CreateSpaceToBatchNDOptions(_fbb, ptr, _rehasher).Union();
18586 }
18588 auto ptr = reinterpret_cast<const tflite::TransposeOptionsT *>(value);
18589 return CreateTransposeOptions(_fbb, ptr, _rehasher).Union();
18590 }
18592 auto ptr = reinterpret_cast<const tflite::ReducerOptionsT *>(value);
18593 return CreateReducerOptions(_fbb, ptr, _rehasher).Union();
18594 }
18596 auto ptr = reinterpret_cast<const tflite::SubOptionsT *>(value);
18597 return CreateSubOptions(_fbb, ptr, _rehasher).Union();
18598 }
18600 auto ptr = reinterpret_cast<const tflite::DivOptionsT *>(value);
18601 return CreateDivOptions(_fbb, ptr, _rehasher).Union();
18602 }
18604 auto ptr = reinterpret_cast<const tflite::SqueezeOptionsT *>(value);
18605 return CreateSqueezeOptions(_fbb, ptr, _rehasher).Union();
18606 }
18608 auto ptr = reinterpret_cast<const tflite::SequenceRNNOptionsT *>(value);
18609 return CreateSequenceRNNOptions(_fbb, ptr, _rehasher).Union();
18610 }
18612 auto ptr = reinterpret_cast<const tflite::StridedSliceOptionsT *>(value);
18613 return CreateStridedSliceOptions(_fbb, ptr, _rehasher).Union();
18614 }
18616 auto ptr = reinterpret_cast<const tflite::ExpOptionsT *>(value);
18617 return CreateExpOptions(_fbb, ptr, _rehasher).Union();
18618 }
18620 auto ptr = reinterpret_cast<const tflite::TopKV2OptionsT *>(value);
18621 return CreateTopKV2Options(_fbb, ptr, _rehasher).Union();
18622 }
18624 auto ptr = reinterpret_cast<const tflite::SplitOptionsT *>(value);
18625 return CreateSplitOptions(_fbb, ptr, _rehasher).Union();
18626 }
18628 auto ptr = reinterpret_cast<const tflite::LogSoftmaxOptionsT *>(value);
18629 return CreateLogSoftmaxOptions(_fbb, ptr, _rehasher).Union();
18630 }
18632 auto ptr = reinterpret_cast<const tflite::CastOptionsT *>(value);
18633 return CreateCastOptions(_fbb, ptr, _rehasher).Union();
18634 }
18636 auto ptr = reinterpret_cast<const tflite::DequantizeOptionsT *>(value);
18637 return CreateDequantizeOptions(_fbb, ptr, _rehasher).Union();
18638 }
18640 auto ptr = reinterpret_cast<const tflite::MaximumMinimumOptionsT *>(value);
18641 return CreateMaximumMinimumOptions(_fbb, ptr, _rehasher).Union();
18642 }
18644 auto ptr = reinterpret_cast<const tflite::ArgMaxOptionsT *>(value);
18645 return CreateArgMaxOptions(_fbb, ptr, _rehasher).Union();
18646 }
18648 auto ptr = reinterpret_cast<const tflite::LessOptionsT *>(value);
18649 return CreateLessOptions(_fbb, ptr, _rehasher).Union();
18650 }
18652 auto ptr = reinterpret_cast<const tflite::NegOptionsT *>(value);
18653 return CreateNegOptions(_fbb, ptr, _rehasher).Union();
18654 }
18656 auto ptr = reinterpret_cast<const tflite::PadV2OptionsT *>(value);
18657 return CreatePadV2Options(_fbb, ptr, _rehasher).Union();
18658 }
18660 auto ptr = reinterpret_cast<const tflite::GreaterOptionsT *>(value);
18661 return CreateGreaterOptions(_fbb, ptr, _rehasher).Union();
18662 }
18664 auto ptr = reinterpret_cast<const tflite::GreaterEqualOptionsT *>(value);
18665 return CreateGreaterEqualOptions(_fbb, ptr, _rehasher).Union();
18666 }
18668 auto ptr = reinterpret_cast<const tflite::LessEqualOptionsT *>(value);
18669 return CreateLessEqualOptions(_fbb, ptr, _rehasher).Union();
18670 }
18672 auto ptr = reinterpret_cast<const tflite::SelectOptionsT *>(value);
18673 return CreateSelectOptions(_fbb, ptr, _rehasher).Union();
18674 }
18676 auto ptr = reinterpret_cast<const tflite::SliceOptionsT *>(value);
18677 return CreateSliceOptions(_fbb, ptr, _rehasher).Union();
18678 }
18680 auto ptr = reinterpret_cast<const tflite::TransposeConvOptionsT *>(value);
18681 return CreateTransposeConvOptions(_fbb, ptr, _rehasher).Union();
18682 }
18684 auto ptr = reinterpret_cast<const tflite::SparseToDenseOptionsT *>(value);
18685 return CreateSparseToDenseOptions(_fbb, ptr, _rehasher).Union();
18686 }
18688 auto ptr = reinterpret_cast<const tflite::TileOptionsT *>(value);
18689 return CreateTileOptions(_fbb, ptr, _rehasher).Union();
18690 }
18692 auto ptr = reinterpret_cast<const tflite::ExpandDimsOptionsT *>(value);
18693 return CreateExpandDimsOptions(_fbb, ptr, _rehasher).Union();
18694 }
18696 auto ptr = reinterpret_cast<const tflite::EqualOptionsT *>(value);
18697 return CreateEqualOptions(_fbb, ptr, _rehasher).Union();
18698 }
18700 auto ptr = reinterpret_cast<const tflite::NotEqualOptionsT *>(value);
18701 return CreateNotEqualOptions(_fbb, ptr, _rehasher).Union();
18702 }
18704 auto ptr = reinterpret_cast<const tflite::ShapeOptionsT *>(value);
18705 return CreateShapeOptions(_fbb, ptr, _rehasher).Union();
18706 }
18708 auto ptr = reinterpret_cast<const tflite::PowOptionsT *>(value);
18709 return CreatePowOptions(_fbb, ptr, _rehasher).Union();
18710 }
18712 auto ptr = reinterpret_cast<const tflite::ArgMinOptionsT *>(value);
18713 return CreateArgMinOptions(_fbb, ptr, _rehasher).Union();
18714 }
18716 auto ptr = reinterpret_cast<const tflite::FakeQuantOptionsT *>(value);
18717 return CreateFakeQuantOptions(_fbb, ptr, _rehasher).Union();
18718 }
18720 auto ptr = reinterpret_cast<const tflite::PackOptionsT *>(value);
18721 return CreatePackOptions(_fbb, ptr, _rehasher).Union();
18722 }
18724 auto ptr = reinterpret_cast<const tflite::LogicalOrOptionsT *>(value);
18725 return CreateLogicalOrOptions(_fbb, ptr, _rehasher).Union();
18726 }
18728 auto ptr = reinterpret_cast<const tflite::OneHotOptionsT *>(value);
18729 return CreateOneHotOptions(_fbb, ptr, _rehasher).Union();
18730 }
18732 auto ptr = reinterpret_cast<const tflite::LogicalAndOptionsT *>(value);
18733 return CreateLogicalAndOptions(_fbb, ptr, _rehasher).Union();
18734 }
18736 auto ptr = reinterpret_cast<const tflite::LogicalNotOptionsT *>(value);
18737 return CreateLogicalNotOptions(_fbb, ptr, _rehasher).Union();
18738 }
18740 auto ptr = reinterpret_cast<const tflite::UnpackOptionsT *>(value);
18741 return CreateUnpackOptions(_fbb, ptr, _rehasher).Union();
18742 }
18744 auto ptr = reinterpret_cast<const tflite::FloorDivOptionsT *>(value);
18745 return CreateFloorDivOptions(_fbb, ptr, _rehasher).Union();
18746 }
18748 auto ptr = reinterpret_cast<const tflite::SquareOptionsT *>(value);
18749 return CreateSquareOptions(_fbb, ptr, _rehasher).Union();
18750 }
18752 auto ptr = reinterpret_cast<const tflite::ZerosLikeOptionsT *>(value);
18753 return CreateZerosLikeOptions(_fbb, ptr, _rehasher).Union();
18754 }
18756 auto ptr = reinterpret_cast<const tflite::FillOptionsT *>(value);
18757 return CreateFillOptions(_fbb, ptr, _rehasher).Union();
18758 }
18760 auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceLSTMOptionsT *>(value);
18761 return CreateBidirectionalSequenceLSTMOptions(_fbb, ptr, _rehasher).Union();
18762 }
18764 auto ptr = reinterpret_cast<const tflite::BidirectionalSequenceRNNOptionsT *>(value);
18765 return CreateBidirectionalSequenceRNNOptions(_fbb, ptr, _rehasher).Union();
18766 }
18768 auto ptr = reinterpret_cast<const tflite::UnidirectionalSequenceLSTMOptionsT *>(value);
18769 return CreateUnidirectionalSequenceLSTMOptions(_fbb, ptr, _rehasher).Union();
18770 }
18772 auto ptr = reinterpret_cast<const tflite::FloorModOptionsT *>(value);
18773 return CreateFloorModOptions(_fbb, ptr, _rehasher).Union();
18774 }
18776 auto ptr = reinterpret_cast<const tflite::RangeOptionsT *>(value);
18777 return CreateRangeOptions(_fbb, ptr, _rehasher).Union();
18778 }
18780 auto ptr = reinterpret_cast<const tflite::ResizeNearestNeighborOptionsT *>(value);
18781 return CreateResizeNearestNeighborOptions(_fbb, ptr, _rehasher).Union();
18782 }
18784 auto ptr = reinterpret_cast<const tflite::LeakyReluOptionsT *>(value);
18785 return CreateLeakyReluOptions(_fbb, ptr, _rehasher).Union();
18786 }
18788 auto ptr = reinterpret_cast<const tflite::SquaredDifferenceOptionsT *>(value);
18789 return CreateSquaredDifferenceOptions(_fbb, ptr, _rehasher).Union();
18790 }
18792 auto ptr = reinterpret_cast<const tflite::MirrorPadOptionsT *>(value);
18793 return CreateMirrorPadOptions(_fbb, ptr, _rehasher).Union();
18794 }
18796 auto ptr = reinterpret_cast<const tflite::AbsOptionsT *>(value);
18797 return CreateAbsOptions(_fbb, ptr, _rehasher).Union();
18798 }
18800 auto ptr = reinterpret_cast<const tflite::SplitVOptionsT *>(value);
18801 return CreateSplitVOptions(_fbb, ptr, _rehasher).Union();
18802 }
18804 auto ptr = reinterpret_cast<const tflite::UniqueOptionsT *>(value);
18805 return CreateUniqueOptions(_fbb, ptr, _rehasher).Union();
18806 }
18808 auto ptr = reinterpret_cast<const tflite::ReverseV2OptionsT *>(value);
18809 return CreateReverseV2Options(_fbb, ptr, _rehasher).Union();
18810 }
18812 auto ptr = reinterpret_cast<const tflite::AddNOptionsT *>(value);
18813 return CreateAddNOptions(_fbb, ptr, _rehasher).Union();
18814 }
18816 auto ptr = reinterpret_cast<const tflite::GatherNdOptionsT *>(value);
18817 return CreateGatherNdOptions(_fbb, ptr, _rehasher).Union();
18818 }
18820 auto ptr = reinterpret_cast<const tflite::CosOptionsT *>(value);
18821 return CreateCosOptions(_fbb, ptr, _rehasher).Union();
18822 }
18824 auto ptr = reinterpret_cast<const tflite::WhereOptionsT *>(value);
18825 return CreateWhereOptions(_fbb, ptr, _rehasher).Union();
18826 }
18828 auto ptr = reinterpret_cast<const tflite::RankOptionsT *>(value);
18829 return CreateRankOptions(_fbb, ptr, _rehasher).Union();
18830 }
18832 auto ptr = reinterpret_cast<const tflite::ReverseSequenceOptionsT *>(value);
18833 return CreateReverseSequenceOptions(_fbb, ptr, _rehasher).Union();
18834 }
18836 auto ptr = reinterpret_cast<const tflite::MatrixDiagOptionsT *>(value);
18837 return CreateMatrixDiagOptions(_fbb, ptr, _rehasher).Union();
18838 }
18840 auto ptr = reinterpret_cast<const tflite::QuantizeOptionsT *>(value);
18841 return CreateQuantizeOptions(_fbb, ptr, _rehasher).Union();
18842 }
18844 auto ptr = reinterpret_cast<const tflite::MatrixSetDiagOptionsT *>(value);
18845 return CreateMatrixSetDiagOptions(_fbb, ptr, _rehasher).Union();
18846 }
18848 auto ptr = reinterpret_cast<const tflite::HardSwishOptionsT *>(value);
18849 return CreateHardSwishOptions(_fbb, ptr, _rehasher).Union();
18850 }
18852 auto ptr = reinterpret_cast<const tflite::IfOptionsT *>(value);
18853 return CreateIfOptions(_fbb, ptr, _rehasher).Union();
18854 }
18856 auto ptr = reinterpret_cast<const tflite::WhileOptionsT *>(value);
18857 return CreateWhileOptions(_fbb, ptr, _rehasher).Union();
18858 }
18860 auto ptr = reinterpret_cast<const tflite::DepthToSpaceOptionsT *>(value);
18861 return CreateDepthToSpaceOptions(_fbb, ptr, _rehasher).Union();
18862 }
18864 auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV4OptionsT *>(value);
18865 return CreateNonMaxSuppressionV4Options(_fbb, ptr, _rehasher).Union();
18866 }
18868 auto ptr = reinterpret_cast<const tflite::NonMaxSuppressionV5OptionsT *>(value);
18869 return CreateNonMaxSuppressionV5Options(_fbb, ptr, _rehasher).Union();
18870 }
18872 auto ptr = reinterpret_cast<const tflite::ScatterNdOptionsT *>(value);
18873 return CreateScatterNdOptions(_fbb, ptr, _rehasher).Union();
18874 }
18876 auto ptr = reinterpret_cast<const tflite::SelectV2OptionsT *>(value);
18877 return CreateSelectV2Options(_fbb, ptr, _rehasher).Union();
18878 }
18880 auto ptr = reinterpret_cast<const tflite::DensifyOptionsT *>(value);
18881 return CreateDensifyOptions(_fbb, ptr, _rehasher).Union();
18882 }
18884 auto ptr = reinterpret_cast<const tflite::SegmentSumOptionsT *>(value);
18885 return CreateSegmentSumOptions(_fbb, ptr, _rehasher).Union();
18886 }
18888 auto ptr = reinterpret_cast<const tflite::BatchMatMulOptionsT *>(value);
18889 return CreateBatchMatMulOptions(_fbb, ptr, _rehasher).Union();
18890 }
18892 auto ptr = reinterpret_cast<const tflite::CumsumOptionsT *>(value);
18893 return CreateCumsumOptions(_fbb, ptr, _rehasher).Union();
18894 }
18896 auto ptr = reinterpret_cast<const tflite::CallOnceOptionsT *>(value);
18897 return CreateCallOnceOptions(_fbb, ptr, _rehasher).Union();
18898 }
18900 auto ptr = reinterpret_cast<const tflite::BroadcastToOptionsT *>(value);
18901 return CreateBroadcastToOptions(_fbb, ptr, _rehasher).Union();
18902 }
18904 auto ptr = reinterpret_cast<const tflite::Rfft2dOptionsT *>(value);
18905 return CreateRfft2dOptions(_fbb, ptr, _rehasher).Union();
18906 }
18908 auto ptr = reinterpret_cast<const tflite::Conv3DOptionsT *>(value);
18909 return CreateConv3DOptions(_fbb, ptr, _rehasher).Union();
18910 }
18912 auto ptr = reinterpret_cast<const tflite::HashtableOptionsT *>(value);
18913 return CreateHashtableOptions(_fbb, ptr, _rehasher).Union();
18914 }
18916 auto ptr = reinterpret_cast<const tflite::HashtableFindOptionsT *>(value);
18917 return CreateHashtableFindOptions(_fbb, ptr, _rehasher).Union();
18918 }
18920 auto ptr = reinterpret_cast<const tflite::HashtableImportOptionsT *>(value);
18921 return CreateHashtableImportOptions(_fbb, ptr, _rehasher).Union();
18922 }
18924 auto ptr = reinterpret_cast<const tflite::HashtableSizeOptionsT *>(value);
18925 return CreateHashtableSizeOptions(_fbb, ptr, _rehasher).Union();
18926 }
18928 auto ptr = reinterpret_cast<const tflite::VarHandleOptionsT *>(value);
18929 return CreateVarHandleOptions(_fbb, ptr, _rehasher).Union();
18930 }
18932 auto ptr = reinterpret_cast<const tflite::ReadVariableOptionsT *>(value);
18933 return CreateReadVariableOptions(_fbb, ptr, _rehasher).Union();
18934 }
18936 auto ptr = reinterpret_cast<const tflite::AssignVariableOptionsT *>(value);
18937 return CreateAssignVariableOptions(_fbb, ptr, _rehasher).Union();
18938 }
18940 auto ptr = reinterpret_cast<const tflite::RandomOptionsT *>(value);
18941 return CreateRandomOptions(_fbb, ptr, _rehasher).Union();
18942 }
18944 auto ptr = reinterpret_cast<const tflite::BucketizeOptionsT *>(value);
18945 return CreateBucketizeOptions(_fbb, ptr, _rehasher).Union();
18946 }
18948 auto ptr = reinterpret_cast<const tflite::GeluOptionsT *>(value);
18949 return CreateGeluOptions(_fbb, ptr, _rehasher).Union();
18950 }
18952 auto ptr = reinterpret_cast<const tflite::DynamicUpdateSliceOptionsT *>(value);
18953 return CreateDynamicUpdateSliceOptions(_fbb, ptr, _rehasher).Union();
18954 }
18956 auto ptr = reinterpret_cast<const tflite::UnsortedSegmentProdOptionsT *>(value);
18957 return CreateUnsortedSegmentProdOptions(_fbb, ptr, _rehasher).Union();
18958 }
18960 auto ptr = reinterpret_cast<const tflite::UnsortedSegmentMaxOptionsT *>(value);
18961 return CreateUnsortedSegmentMaxOptions(_fbb, ptr, _rehasher).Union();
18962 }
18964 auto ptr = reinterpret_cast<const tflite::UnsortedSegmentMinOptionsT *>(value);
18965 return CreateUnsortedSegmentMinOptions(_fbb, ptr, _rehasher).Union();
18966 }
18968 auto ptr = reinterpret_cast<const tflite::UnsortedSegmentSumOptionsT *>(value);
18969 return CreateUnsortedSegmentSumOptions(_fbb, ptr, _rehasher).Union();
18970 }
18972 auto ptr = reinterpret_cast<const tflite::ATan2OptionsT *>(value);
18973 return CreateATan2Options(_fbb, ptr, _rehasher).Union();
18974 }
18976 auto ptr = reinterpret_cast<const tflite::SignOptionsT *>(value);
18977 return CreateSignOptions(_fbb, ptr, _rehasher).Union();
18978 }
18979 default: return 0;
18980 }
18981}
18982
18984 switch (type) {
18986 value = new tflite::Conv2DOptionsT(*reinterpret_cast<tflite::Conv2DOptionsT *>(u.value));
18987 break;
18988 }
18991 break;
18992 }
18995 break;
18996 }
18999 break;
19000 }
19002 value = new tflite::Pool2DOptionsT(*reinterpret_cast<tflite::Pool2DOptionsT *>(u.value));
19003 break;
19004 }
19006 value = new tflite::SVDFOptionsT(*reinterpret_cast<tflite::SVDFOptionsT *>(u.value));
19007 break;
19008 }
19010 value = new tflite::RNNOptionsT(*reinterpret_cast<tflite::RNNOptionsT *>(u.value));
19011 break;
19012 }
19015 break;
19016 }
19018 value = new tflite::SoftmaxOptionsT(*reinterpret_cast<tflite::SoftmaxOptionsT *>(u.value));
19019 break;
19020 }
19023 break;
19024 }
19026 value = new tflite::AddOptionsT(*reinterpret_cast<tflite::AddOptionsT *>(u.value));
19027 break;
19028 }
19030 value = new tflite::L2NormOptionsT(*reinterpret_cast<tflite::L2NormOptionsT *>(u.value));
19031 break;
19032 }
19035 break;
19036 }
19038 value = new tflite::LSTMOptionsT(*reinterpret_cast<tflite::LSTMOptionsT *>(u.value));
19039 break;
19040 }
19043 break;
19044 }
19046 value = new tflite::CallOptionsT(*reinterpret_cast<tflite::CallOptionsT *>(u.value));
19047 break;
19048 }
19050 value = new tflite::ReshapeOptionsT(*reinterpret_cast<tflite::ReshapeOptionsT *>(u.value));
19051 break;
19052 }
19054 value = new tflite::SkipGramOptionsT(*reinterpret_cast<tflite::SkipGramOptionsT *>(u.value));
19055 break;
19056 }
19059 break;
19060 }
19063 break;
19064 }
19066 value = new tflite::MulOptionsT(*reinterpret_cast<tflite::MulOptionsT *>(u.value));
19067 break;
19068 }
19070 value = new tflite::PadOptionsT(*reinterpret_cast<tflite::PadOptionsT *>(u.value));
19071 break;
19072 }
19074 value = new tflite::GatherOptionsT(*reinterpret_cast<tflite::GatherOptionsT *>(u.value));
19075 break;
19076 }
19079 break;
19080 }
19083 break;
19084 }
19086 value = new tflite::TransposeOptionsT(*reinterpret_cast<tflite::TransposeOptionsT *>(u.value));
19087 break;
19088 }
19090 value = new tflite::ReducerOptionsT(*reinterpret_cast<tflite::ReducerOptionsT *>(u.value));
19091 break;
19092 }
19094 value = new tflite::SubOptionsT(*reinterpret_cast<tflite::SubOptionsT *>(u.value));
19095 break;
19096 }
19098 value = new tflite::DivOptionsT(*reinterpret_cast<tflite::DivOptionsT *>(u.value));
19099 break;
19100 }
19102 value = new tflite::SqueezeOptionsT(*reinterpret_cast<tflite::SqueezeOptionsT *>(u.value));
19103 break;
19104 }
19107 break;
19108 }
19111 break;
19112 }
19114 value = new tflite::ExpOptionsT(*reinterpret_cast<tflite::ExpOptionsT *>(u.value));
19115 break;
19116 }
19118 value = new tflite::TopKV2OptionsT(*reinterpret_cast<tflite::TopKV2OptionsT *>(u.value));
19119 break;
19120 }
19122 value = new tflite::SplitOptionsT(*reinterpret_cast<tflite::SplitOptionsT *>(u.value));
19123 break;
19124 }
19127 break;
19128 }
19130 value = new tflite::CastOptionsT(*reinterpret_cast<tflite::CastOptionsT *>(u.value));
19131 break;
19132 }
19135 break;
19136 }
19139 break;
19140 }
19142 value = new tflite::ArgMaxOptionsT(*reinterpret_cast<tflite::ArgMaxOptionsT *>(u.value));
19143 break;
19144 }
19146 value = new tflite::LessOptionsT(*reinterpret_cast<tflite::LessOptionsT *>(u.value));
19147 break;
19148 }
19150 value = new tflite::NegOptionsT(*reinterpret_cast<tflite::NegOptionsT *>(u.value));
19151 break;
19152 }
19154 value = new tflite::PadV2OptionsT(*reinterpret_cast<tflite::PadV2OptionsT *>(u.value));
19155 break;
19156 }
19158 value = new tflite::GreaterOptionsT(*reinterpret_cast<tflite::GreaterOptionsT *>(u.value));
19159 break;
19160 }
19163 break;
19164 }
19166 value = new tflite::LessEqualOptionsT(*reinterpret_cast<tflite::LessEqualOptionsT *>(u.value));
19167 break;
19168 }
19170 value = new tflite::SelectOptionsT(*reinterpret_cast<tflite::SelectOptionsT *>(u.value));
19171 break;
19172 }
19174 value = new tflite::SliceOptionsT(*reinterpret_cast<tflite::SliceOptionsT *>(u.value));
19175 break;
19176 }
19179 break;
19180 }
19183 break;
19184 }
19186 value = new tflite::TileOptionsT(*reinterpret_cast<tflite::TileOptionsT *>(u.value));
19187 break;
19188 }
19191 break;
19192 }
19194 value = new tflite::EqualOptionsT(*reinterpret_cast<tflite::EqualOptionsT *>(u.value));
19195 break;
19196 }
19198 value = new tflite::NotEqualOptionsT(*reinterpret_cast<tflite::NotEqualOptionsT *>(u.value));
19199 break;
19200 }
19202 value = new tflite::ShapeOptionsT(*reinterpret_cast<tflite::ShapeOptionsT *>(u.value));
19203 break;
19204 }
19206 value = new tflite::PowOptionsT(*reinterpret_cast<tflite::PowOptionsT *>(u.value));
19207 break;
19208 }
19210 value = new tflite::ArgMinOptionsT(*reinterpret_cast<tflite::ArgMinOptionsT *>(u.value));
19211 break;
19212 }
19214 value = new tflite::FakeQuantOptionsT(*reinterpret_cast<tflite::FakeQuantOptionsT *>(u.value));
19215 break;
19216 }
19218 value = new tflite::PackOptionsT(*reinterpret_cast<tflite::PackOptionsT *>(u.value));
19219 break;
19220 }
19222 value = new tflite::LogicalOrOptionsT(*reinterpret_cast<tflite::LogicalOrOptionsT *>(u.value));
19223 break;
19224 }
19226 value = new tflite::OneHotOptionsT(*reinterpret_cast<tflite::OneHotOptionsT *>(u.value));
19227 break;
19228 }
19231 break;
19232 }
19235 break;
19236 }
19238 value = new tflite::UnpackOptionsT(*reinterpret_cast<tflite::UnpackOptionsT *>(u.value));
19239 break;
19240 }
19242 value = new tflite::FloorDivOptionsT(*reinterpret_cast<tflite::FloorDivOptionsT *>(u.value));
19243 break;
19244 }
19246 value = new tflite::SquareOptionsT(*reinterpret_cast<tflite::SquareOptionsT *>(u.value));
19247 break;
19248 }
19250 value = new tflite::ZerosLikeOptionsT(*reinterpret_cast<tflite::ZerosLikeOptionsT *>(u.value));
19251 break;
19252 }
19254 value = new tflite::FillOptionsT(*reinterpret_cast<tflite::FillOptionsT *>(u.value));
19255 break;
19256 }
19259 break;
19260 }
19263 break;
19264 }
19267 break;
19268 }
19270 value = new tflite::FloorModOptionsT(*reinterpret_cast<tflite::FloorModOptionsT *>(u.value));
19271 break;
19272 }
19274 value = new tflite::RangeOptionsT(*reinterpret_cast<tflite::RangeOptionsT *>(u.value));
19275 break;
19276 }
19279 break;
19280 }
19282 value = new tflite::LeakyReluOptionsT(*reinterpret_cast<tflite::LeakyReluOptionsT *>(u.value));
19283 break;
19284 }
19287 break;
19288 }
19290 value = new tflite::MirrorPadOptionsT(*reinterpret_cast<tflite::MirrorPadOptionsT *>(u.value));
19291 break;
19292 }
19294 value = new tflite::AbsOptionsT(*reinterpret_cast<tflite::AbsOptionsT *>(u.value));
19295 break;
19296 }
19298 value = new tflite::SplitVOptionsT(*reinterpret_cast<tflite::SplitVOptionsT *>(u.value));
19299 break;
19300 }
19302 value = new tflite::UniqueOptionsT(*reinterpret_cast<tflite::UniqueOptionsT *>(u.value));
19303 break;
19304 }
19306 value = new tflite::ReverseV2OptionsT(*reinterpret_cast<tflite::ReverseV2OptionsT *>(u.value));
19307 break;
19308 }
19310 value = new tflite::AddNOptionsT(*reinterpret_cast<tflite::AddNOptionsT *>(u.value));
19311 break;
19312 }
19314 value = new tflite::GatherNdOptionsT(*reinterpret_cast<tflite::GatherNdOptionsT *>(u.value));
19315 break;
19316 }
19318 value = new tflite::CosOptionsT(*reinterpret_cast<tflite::CosOptionsT *>(u.value));
19319 break;
19320 }
19322 value = new tflite::WhereOptionsT(*reinterpret_cast<tflite::WhereOptionsT *>(u.value));
19323 break;
19324 }
19326 value = new tflite::RankOptionsT(*reinterpret_cast<tflite::RankOptionsT *>(u.value));
19327 break;
19328 }
19331 break;
19332 }
19335 break;
19336 }
19338 value = new tflite::QuantizeOptionsT(*reinterpret_cast<tflite::QuantizeOptionsT *>(u.value));
19339 break;
19340 }
19343 break;
19344 }
19346 value = new tflite::HardSwishOptionsT(*reinterpret_cast<tflite::HardSwishOptionsT *>(u.value));
19347 break;
19348 }
19350 value = new tflite::IfOptionsT(*reinterpret_cast<tflite::IfOptionsT *>(u.value));
19351 break;
19352 }
19354 value = new tflite::WhileOptionsT(*reinterpret_cast<tflite::WhileOptionsT *>(u.value));
19355 break;
19356 }
19359 break;
19360 }
19363 break;
19364 }
19367 break;
19368 }
19370 value = new tflite::ScatterNdOptionsT(*reinterpret_cast<tflite::ScatterNdOptionsT *>(u.value));
19371 break;
19372 }
19374 value = new tflite::SelectV2OptionsT(*reinterpret_cast<tflite::SelectV2OptionsT *>(u.value));
19375 break;
19376 }
19378 value = new tflite::DensifyOptionsT(*reinterpret_cast<tflite::DensifyOptionsT *>(u.value));
19379 break;
19380 }
19383 break;
19384 }
19387 break;
19388 }
19390 value = new tflite::CumsumOptionsT(*reinterpret_cast<tflite::CumsumOptionsT *>(u.value));
19391 break;
19392 }
19394 value = new tflite::CallOnceOptionsT(*reinterpret_cast<tflite::CallOnceOptionsT *>(u.value));
19395 break;
19396 }
19399 break;
19400 }
19402 value = new tflite::Rfft2dOptionsT(*reinterpret_cast<tflite::Rfft2dOptionsT *>(u.value));
19403 break;
19404 }
19406 value = new tflite::Conv3DOptionsT(*reinterpret_cast<tflite::Conv3DOptionsT *>(u.value));
19407 break;
19408 }
19410 value = new tflite::HashtableOptionsT(*reinterpret_cast<tflite::HashtableOptionsT *>(u.value));
19411 break;
19412 }
19415 break;
19416 }
19419 break;
19420 }
19423 break;
19424 }
19426 value = new tflite::VarHandleOptionsT(*reinterpret_cast<tflite::VarHandleOptionsT *>(u.value));
19427 break;
19428 }
19431 break;
19432 }
19435 break;
19436 }
19438 value = new tflite::RandomOptionsT(*reinterpret_cast<tflite::RandomOptionsT *>(u.value));
19439 break;
19440 }
19442 value = new tflite::BucketizeOptionsT(*reinterpret_cast<tflite::BucketizeOptionsT *>(u.value));
19443 break;
19444 }
19446 value = new tflite::GeluOptionsT(*reinterpret_cast<tflite::GeluOptionsT *>(u.value));
19447 break;
19448 }
19451 break;
19452 }
19455 break;
19456 }
19459 break;
19460 }
19463 break;
19464 }
19467 break;
19468 }
19470 value = new tflite::ATan2OptionsT(*reinterpret_cast<tflite::ATan2OptionsT *>(u.value));
19471 break;
19472 }
19474 value = new tflite::SignOptionsT(*reinterpret_cast<tflite::SignOptionsT *>(u.value));
19475 break;
19476 }
19477 default:
19478 break;
19479 }
19480}
19481
19483 switch (type) {
19485 auto ptr = reinterpret_cast<tflite::Conv2DOptionsT *>(value);
19486 delete ptr;
19487 break;
19488 }
19490 auto ptr = reinterpret_cast<tflite::DepthwiseConv2DOptionsT *>(value);
19491 delete ptr;
19492 break;
19493 }
19495 auto ptr = reinterpret_cast<tflite::ConcatEmbeddingsOptionsT *>(value);
19496 delete ptr;
19497 break;
19498 }
19500 auto ptr = reinterpret_cast<tflite::LSHProjectionOptionsT *>(value);
19501 delete ptr;
19502 break;
19503 }
19505 auto ptr = reinterpret_cast<tflite::Pool2DOptionsT *>(value);
19506 delete ptr;
19507 break;
19508 }
19510 auto ptr = reinterpret_cast<tflite::SVDFOptionsT *>(value);
19511 delete ptr;
19512 break;
19513 }
19515 auto ptr = reinterpret_cast<tflite::RNNOptionsT *>(value);
19516 delete ptr;
19517 break;
19518 }
19520 auto ptr = reinterpret_cast<tflite::FullyConnectedOptionsT *>(value);
19521 delete ptr;
19522 break;
19523 }
19525 auto ptr = reinterpret_cast<tflite::SoftmaxOptionsT *>(value);
19526 delete ptr;
19527 break;
19528 }
19530 auto ptr = reinterpret_cast<tflite::ConcatenationOptionsT *>(value);
19531 delete ptr;
19532 break;
19533 }
19535 auto ptr = reinterpret_cast<tflite::AddOptionsT *>(value);
19536 delete ptr;
19537 break;
19538 }
19540 auto ptr = reinterpret_cast<tflite::L2NormOptionsT *>(value);
19541 delete ptr;
19542 break;
19543 }
19545 auto ptr = reinterpret_cast<tflite::LocalResponseNormalizationOptionsT *>(value);
19546 delete ptr;
19547 break;
19548 }
19550 auto ptr = reinterpret_cast<tflite::LSTMOptionsT *>(value);
19551 delete ptr;
19552 break;
19553 }
19555 auto ptr = reinterpret_cast<tflite::ResizeBilinearOptionsT *>(value);
19556 delete ptr;
19557 break;
19558 }
19560 auto ptr = reinterpret_cast<tflite::CallOptionsT *>(value);
19561 delete ptr;
19562 break;
19563 }
19565 auto ptr = reinterpret_cast<tflite::ReshapeOptionsT *>(value);
19566 delete ptr;
19567 break;
19568 }
19570 auto ptr = reinterpret_cast<tflite::SkipGramOptionsT *>(value);
19571 delete ptr;
19572 break;
19573 }
19575 auto ptr = reinterpret_cast<tflite::SpaceToDepthOptionsT *>(value);
19576 delete ptr;
19577 break;
19578 }
19580 auto ptr = reinterpret_cast<tflite::EmbeddingLookupSparseOptionsT *>(value);
19581 delete ptr;
19582 break;
19583 }
19585 auto ptr = reinterpret_cast<tflite::MulOptionsT *>(value);
19586 delete ptr;
19587 break;
19588 }
19590 auto ptr = reinterpret_cast<tflite::PadOptionsT *>(value);
19591 delete ptr;
19592 break;
19593 }
19595 auto ptr = reinterpret_cast<tflite::GatherOptionsT *>(value);
19596 delete ptr;
19597 break;
19598 }
19600 auto ptr = reinterpret_cast<tflite::BatchToSpaceNDOptionsT *>(value);
19601 delete ptr;
19602 break;
19603 }
19605 auto ptr = reinterpret_cast<tflite::SpaceToBatchNDOptionsT *>(value);
19606 delete ptr;
19607 break;
19608 }
19610 auto ptr = reinterpret_cast<tflite::TransposeOptionsT *>(value);
19611 delete ptr;
19612 break;
19613 }
19615 auto ptr = reinterpret_cast<tflite::ReducerOptionsT *>(value);
19616 delete ptr;
19617 break;
19618 }
19620 auto ptr = reinterpret_cast<tflite::SubOptionsT *>(value);
19621 delete ptr;
19622 break;
19623 }
19625 auto ptr = reinterpret_cast<tflite::DivOptionsT *>(value);
19626 delete ptr;
19627 break;
19628 }
19630 auto ptr = reinterpret_cast<tflite::SqueezeOptionsT *>(value);
19631 delete ptr;
19632 break;
19633 }
19635 auto ptr = reinterpret_cast<tflite::SequenceRNNOptionsT *>(value);
19636 delete ptr;
19637 break;
19638 }
19640 auto ptr = reinterpret_cast<tflite::StridedSliceOptionsT *>(value);
19641 delete ptr;
19642 break;
19643 }
19645 auto ptr = reinterpret_cast<tflite::ExpOptionsT *>(value);
19646 delete ptr;
19647 break;
19648 }
19650 auto ptr = reinterpret_cast<tflite::TopKV2OptionsT *>(value);
19651 delete ptr;
19652 break;
19653 }
19655 auto ptr = reinterpret_cast<tflite::SplitOptionsT *>(value);
19656 delete ptr;
19657 break;
19658 }
19660 auto ptr = reinterpret_cast<tflite::LogSoftmaxOptionsT *>(value);
19661 delete ptr;
19662 break;
19663 }
19665 auto ptr = reinterpret_cast<tflite::CastOptionsT *>(value);
19666 delete ptr;
19667 break;
19668 }
19670 auto ptr = reinterpret_cast<tflite::DequantizeOptionsT *>(value);
19671 delete ptr;
19672 break;
19673 }
19675 auto ptr = reinterpret_cast<tflite::MaximumMinimumOptionsT *>(value);
19676 delete ptr;
19677 break;
19678 }
19680 auto ptr = reinterpret_cast<tflite::ArgMaxOptionsT *>(value);
19681 delete ptr;
19682 break;
19683 }
19685 auto ptr = reinterpret_cast<tflite::LessOptionsT *>(value);
19686 delete ptr;
19687 break;
19688 }
19690 auto ptr = reinterpret_cast<tflite::NegOptionsT *>(value);
19691 delete ptr;
19692 break;
19693 }
19695 auto ptr = reinterpret_cast<tflite::PadV2OptionsT *>(value);
19696 delete ptr;
19697 break;
19698 }
19700 auto ptr = reinterpret_cast<tflite::GreaterOptionsT *>(value);
19701 delete ptr;
19702 break;
19703 }
19705 auto ptr = reinterpret_cast<tflite::GreaterEqualOptionsT *>(value);
19706 delete ptr;
19707 break;
19708 }
19710 auto ptr = reinterpret_cast<tflite::LessEqualOptionsT *>(value);
19711 delete ptr;
19712 break;
19713 }
19715 auto ptr = reinterpret_cast<tflite::SelectOptionsT *>(value);
19716 delete ptr;
19717 break;
19718 }
19720 auto ptr = reinterpret_cast<tflite::SliceOptionsT *>(value);
19721 delete ptr;
19722 break;
19723 }
19725 auto ptr = reinterpret_cast<tflite::TransposeConvOptionsT *>(value);
19726 delete ptr;
19727 break;
19728 }
19730 auto ptr = reinterpret_cast<tflite::SparseToDenseOptionsT *>(value);
19731 delete ptr;
19732 break;
19733 }
19735 auto ptr = reinterpret_cast<tflite::TileOptionsT *>(value);
19736 delete ptr;
19737 break;
19738 }
19740 auto ptr = reinterpret_cast<tflite::ExpandDimsOptionsT *>(value);
19741 delete ptr;
19742 break;
19743 }
19745 auto ptr = reinterpret_cast<tflite::EqualOptionsT *>(value);
19746 delete ptr;
19747 break;
19748 }
19750 auto ptr = reinterpret_cast<tflite::NotEqualOptionsT *>(value);
19751 delete ptr;
19752 break;
19753 }
19755 auto ptr = reinterpret_cast<tflite::ShapeOptionsT *>(value);
19756 delete ptr;
19757 break;
19758 }
19760 auto ptr = reinterpret_cast<tflite::PowOptionsT *>(value);
19761 delete ptr;
19762 break;
19763 }
19765 auto ptr = reinterpret_cast<tflite::ArgMinOptionsT *>(value);
19766 delete ptr;
19767 break;
19768 }
19770 auto ptr = reinterpret_cast<tflite::FakeQuantOptionsT *>(value);
19771 delete ptr;
19772 break;
19773 }
19775 auto ptr = reinterpret_cast<tflite::PackOptionsT *>(value);
19776 delete ptr;
19777 break;
19778 }
19780 auto ptr = reinterpret_cast<tflite::LogicalOrOptionsT *>(value);
19781 delete ptr;
19782 break;
19783 }
19785 auto ptr = reinterpret_cast<tflite::OneHotOptionsT *>(value);
19786 delete ptr;
19787 break;
19788 }
19790 auto ptr = reinterpret_cast<tflite::LogicalAndOptionsT *>(value);
19791 delete ptr;
19792 break;
19793 }
19795 auto ptr = reinterpret_cast<tflite::LogicalNotOptionsT *>(value);
19796 delete ptr;
19797 break;
19798 }
19800 auto ptr = reinterpret_cast<tflite::UnpackOptionsT *>(value);
19801 delete ptr;
19802 break;
19803 }
19805 auto ptr = reinterpret_cast<tflite::FloorDivOptionsT *>(value);
19806 delete ptr;
19807 break;
19808 }
19810 auto ptr = reinterpret_cast<tflite::SquareOptionsT *>(value);
19811 delete ptr;
19812 break;
19813 }
19815 auto ptr = reinterpret_cast<tflite::ZerosLikeOptionsT *>(value);
19816 delete ptr;
19817 break;
19818 }
19820 auto ptr = reinterpret_cast<tflite::FillOptionsT *>(value);
19821 delete ptr;
19822 break;
19823 }
19825 auto ptr = reinterpret_cast<tflite::BidirectionalSequenceLSTMOptionsT *>(value);
19826 delete ptr;
19827 break;
19828 }
19830 auto ptr = reinterpret_cast<tflite::BidirectionalSequenceRNNOptionsT *>(value);
19831 delete ptr;
19832 break;
19833 }
19835 auto ptr = reinterpret_cast<tflite::UnidirectionalSequenceLSTMOptionsT *>(value);
19836 delete ptr;
19837 break;
19838 }
19840 auto ptr = reinterpret_cast<tflite::FloorModOptionsT *>(value);
19841 delete ptr;
19842 break;
19843 }
19845 auto ptr = reinterpret_cast<tflite::RangeOptionsT *>(value);
19846 delete ptr;
19847 break;
19848 }
19850 auto ptr = reinterpret_cast<tflite::ResizeNearestNeighborOptionsT *>(value);
19851 delete ptr;
19852 break;
19853 }
19855 auto ptr = reinterpret_cast<tflite::LeakyReluOptionsT *>(value);
19856 delete ptr;
19857 break;
19858 }
19860 auto ptr = reinterpret_cast<tflite::SquaredDifferenceOptionsT *>(value);
19861 delete ptr;
19862 break;
19863 }
19865 auto ptr = reinterpret_cast<tflite::MirrorPadOptionsT *>(value);
19866 delete ptr;
19867 break;
19868 }
19870 auto ptr = reinterpret_cast<tflite::AbsOptionsT *>(value);
19871 delete ptr;
19872 break;
19873 }
19875 auto ptr = reinterpret_cast<tflite::SplitVOptionsT *>(value);
19876 delete ptr;
19877 break;
19878 }
19880 auto ptr = reinterpret_cast<tflite::UniqueOptionsT *>(value);
19881 delete ptr;
19882 break;
19883 }
19885 auto ptr = reinterpret_cast<tflite::ReverseV2OptionsT *>(value);
19886 delete ptr;
19887 break;
19888 }
19890 auto ptr = reinterpret_cast<tflite::AddNOptionsT *>(value);
19891 delete ptr;
19892 break;
19893 }
19895 auto ptr = reinterpret_cast<tflite::GatherNdOptionsT *>(value);
19896 delete ptr;
19897 break;
19898 }
19900 auto ptr = reinterpret_cast<tflite::CosOptionsT *>(value);
19901 delete ptr;
19902 break;
19903 }
19905 auto ptr = reinterpret_cast<tflite::WhereOptionsT *>(value);
19906 delete ptr;
19907 break;
19908 }
19910 auto ptr = reinterpret_cast<tflite::RankOptionsT *>(value);
19911 delete ptr;
19912 break;
19913 }
19915 auto ptr = reinterpret_cast<tflite::ReverseSequenceOptionsT *>(value);
19916 delete ptr;
19917 break;
19918 }
19920 auto ptr = reinterpret_cast<tflite::MatrixDiagOptionsT *>(value);
19921 delete ptr;
19922 break;
19923 }
19925 auto ptr = reinterpret_cast<tflite::QuantizeOptionsT *>(value);
19926 delete ptr;
19927 break;
19928 }
19930 auto ptr = reinterpret_cast<tflite::MatrixSetDiagOptionsT *>(value);
19931 delete ptr;
19932 break;
19933 }
19935 auto ptr = reinterpret_cast<tflite::HardSwishOptionsT *>(value);
19936 delete ptr;
19937 break;
19938 }
19940 auto ptr = reinterpret_cast<tflite::IfOptionsT *>(value);
19941 delete ptr;
19942 break;
19943 }
19945 auto ptr = reinterpret_cast<tflite::WhileOptionsT *>(value);
19946 delete ptr;
19947 break;
19948 }
19950 auto ptr = reinterpret_cast<tflite::DepthToSpaceOptionsT *>(value);
19951 delete ptr;
19952 break;
19953 }
19955 auto ptr = reinterpret_cast<tflite::NonMaxSuppressionV4OptionsT *>(value);
19956 delete ptr;
19957 break;
19958 }
19960 auto ptr = reinterpret_cast<tflite::NonMaxSuppressionV5OptionsT *>(value);
19961 delete ptr;
19962 break;
19963 }
19965 auto ptr = reinterpret_cast<tflite::ScatterNdOptionsT *>(value);
19966 delete ptr;
19967 break;
19968 }
19970 auto ptr = reinterpret_cast<tflite::SelectV2OptionsT *>(value);
19971 delete ptr;
19972 break;
19973 }
19975 auto ptr = reinterpret_cast<tflite::DensifyOptionsT *>(value);
19976 delete ptr;
19977 break;
19978 }
19980 auto ptr = reinterpret_cast<tflite::SegmentSumOptionsT *>(value);
19981 delete ptr;
19982 break;
19983 }
19985 auto ptr = reinterpret_cast<tflite::BatchMatMulOptionsT *>(value);
19986 delete ptr;
19987 break;
19988 }
19990 auto ptr = reinterpret_cast<tflite::CumsumOptionsT *>(value);
19991 delete ptr;
19992 break;
19993 }
19995 auto ptr = reinterpret_cast<tflite::CallOnceOptionsT *>(value);
19996 delete ptr;
19997 break;
19998 }
20000 auto ptr = reinterpret_cast<tflite::BroadcastToOptionsT *>(value);
20001 delete ptr;
20002 break;
20003 }
20005 auto ptr = reinterpret_cast<tflite::Rfft2dOptionsT *>(value);
20006 delete ptr;
20007 break;
20008 }
20010 auto ptr = reinterpret_cast<tflite::Conv3DOptionsT *>(value);
20011 delete ptr;
20012 break;
20013 }
20015 auto ptr = reinterpret_cast<tflite::HashtableOptionsT *>(value);
20016 delete ptr;
20017 break;
20018 }
20020 auto ptr = reinterpret_cast<tflite::HashtableFindOptionsT *>(value);
20021 delete ptr;
20022 break;
20023 }
20025 auto ptr = reinterpret_cast<tflite::HashtableImportOptionsT *>(value);
20026 delete ptr;
20027 break;
20028 }
20030 auto ptr = reinterpret_cast<tflite::HashtableSizeOptionsT *>(value);
20031 delete ptr;
20032 break;
20033 }
20035 auto ptr = reinterpret_cast<tflite::VarHandleOptionsT *>(value);
20036 delete ptr;
20037 break;
20038 }
20040 auto ptr = reinterpret_cast<tflite::ReadVariableOptionsT *>(value);
20041 delete ptr;
20042 break;
20043 }
20045 auto ptr = reinterpret_cast<tflite::AssignVariableOptionsT *>(value);
20046 delete ptr;
20047 break;
20048 }
20050 auto ptr = reinterpret_cast<tflite::RandomOptionsT *>(value);
20051 delete ptr;
20052 break;
20053 }
20055 auto ptr = reinterpret_cast<tflite::BucketizeOptionsT *>(value);
20056 delete ptr;
20057 break;
20058 }
20060 auto ptr = reinterpret_cast<tflite::GeluOptionsT *>(value);
20061 delete ptr;
20062 break;
20063 }
20065 auto ptr = reinterpret_cast<tflite::DynamicUpdateSliceOptionsT *>(value);
20066 delete ptr;
20067 break;
20068 }
20070 auto ptr = reinterpret_cast<tflite::UnsortedSegmentProdOptionsT *>(value);
20071 delete ptr;
20072 break;
20073 }
20075 auto ptr = reinterpret_cast<tflite::UnsortedSegmentMaxOptionsT *>(value);
20076 delete ptr;
20077 break;
20078 }
20080 auto ptr = reinterpret_cast<tflite::UnsortedSegmentMinOptionsT *>(value);
20081 delete ptr;
20082 break;
20083 }
20085 auto ptr = reinterpret_cast<tflite::UnsortedSegmentSumOptionsT *>(value);
20086 delete ptr;
20087 break;
20088 }
20090 auto ptr = reinterpret_cast<tflite::ATan2OptionsT *>(value);
20091 delete ptr;
20092 break;
20093 }
20095 auto ptr = reinterpret_cast<tflite::SignOptionsT *>(value);
20096 delete ptr;
20097 break;
20098 }
20099 default: break;
20100 }
20101 value = nullptr;
20103}
20104
20105inline const tflite::Model *GetModel(const void *buf) {
20106 return flatbuffers::GetRoot<tflite::Model>(buf);
20107}
20108
20109inline const tflite::Model *GetSizePrefixedModel(const void *buf) {
20110 return flatbuffers::GetSizePrefixedRoot<tflite::Model>(buf);
20111}
20112
20113inline const char *ModelIdentifier() {
20114 return "TFL3";
20115}
20116
20117inline bool ModelBufferHasIdentifier(const void *buf) {
20118 return flatbuffers::BufferHasIdentifier(
20119 buf, ModelIdentifier());
20120}
20121
20122inline bool SizePrefixedModelBufferHasIdentifier(const void *buf) {
20123 return flatbuffers::BufferHasIdentifier(
20124 buf, ModelIdentifier(), true);
20125}
20126
20128 flatbuffers::Verifier &verifier) {
20129 return verifier.VerifyBuffer<tflite::Model>(ModelIdentifier());
20130}
20131
20133 flatbuffers::Verifier &verifier) {
20134 return verifier.VerifySizePrefixedBuffer<tflite::Model>(ModelIdentifier());
20135}
20136
20137inline const char *ModelExtension() {
20138 return "tflite";
20139}
20140
20143 flatbuffers::Offset<tflite::Model> root) {
20144 fbb.Finish(root, ModelIdentifier());
20145}
20146
20149 flatbuffers::Offset<tflite::Model> root) {
20151}
20152
20153inline std::unique_ptr<tflite::ModelT> UnPackModel(
20154 const void *buf,
20155 const flatbuffers::resolver_function_t *res = nullptr) {
20156 return std::unique_ptr<tflite::ModelT>(GetModel(buf)->UnPack(res));
20157}
20158
20159inline std::unique_ptr<tflite::ModelT> UnPackSizePrefixedModel(
20160 const void *buf,
20161 const flatbuffers::resolver_function_t *res = nullptr) {
20162 return std::unique_ptr<tflite::ModelT>(GetSizePrefixedModel(buf)->UnPack(res));
20163}
20164
20165} // namespace tflite
20166
20167#endif // FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_
for(int i=0;i< input->bytes;i++)
Definition InferenceInputData.cpp:3
TfLitePaddingValues padding
Definition conv.cc:54
QuantizationOpData * quantization
Definition batch_matmul.cc:55
float scale
Definition batch_matmul_test.cc:44
int zero_point
Definition batch_matmul_test.cc:45
int init_subgraph_index
Definition call_once.cpp:35
Helper class to hold data needed in creation of a FlatBuffer. To serialize data, you typically call o...
Definition flatbuffer_builder.h:70
void Finish(Offset< T > root, const char *file_identifier=nullptr)
Finish serializing a buffer by writing the root offset.
Definition flatbuffer_builder.h:1084
Offset< String > CreateString(const char *str, size_t len)
Store a string in the buffer, which can contain any binary data.
Definition flatbuffer_builder.h:460
void FinishSizePrefixed(Offset< T > root, const char *file_identifier=nullptr)
Finish a buffer with a 32 bit size field pre-fixed (size of the buffer following the size field)....
Definition flatbuffer_builder.h:1096
Offset< Vector< T > > CreateVector(const T *v, size_t len)
Serialize an array into a FlatBuffer vector.
Definition flatbuffer_builder.h:626
Definition table.h:27
Definition vector.h:144
E GetEnum(uoffset_t i) const
Definition vector.h:179
uoffset_t size() const
Definition vector.h:159
bool exclusive
Definition cumsum_test.cc:30
int32_t axis
Definition cumsum_test.cc:32
bool reverse
Definition cumsum_test.cc:31
int block_size
Definition depth_to_space_test.cc:30
struct hello_world_model::@544::Node0_0::Inputs inputs
int data[3]
Definition hello_world_model.cc:114
struct hello_world_model::@544::Node0_0::Outputs outputs
int else_subgraph_index
Definition if.cpp:36
int then_subgraph_index
Definition if.cpp:35
int filter_width
Definition l2_pool_2d_test.cc:35
int filter_height
Definition l2_pool_2d_test.cc:36
VT_DATA
Definition layer_by_layer_schema_generated.h:110
VT_TENSOR_INDEX
Definition layer_by_layer_schema_generated.h:107
float alpha
Definition leaky_relu_test.cc:33
TfLiteType type
Definition overlap_add.cc:46
int Model
Definition Konvertierung.py:20
format
Definition calibrate.py:32
name
Definition calibrate.py:101
Definition allocator.h:22
std::function< hash_value_t(void *pointer)> rehasher_function_t
Definition flatbuffers.h:97
std::function< void(void **pointer_adr, hash_value_t hash)> resolver_function_t
Definition flatbuffers.h:96
Definition operator.py:1
Definition context_util.h:26
bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type)
Definition schema_generated.h:17288
flatbuffers::Offset< Buffer > CreateBufferDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint8_t > *data=nullptr)
Definition schema_generated.h:12875
const char *const * EnumNamesTensorType()
Definition schema_generated.h:625
flatbuffers::Offset< SignOptions > CreateSignOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11551
flatbuffers::Offset< BidirectionalSequenceLSTMOptions > CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE, float cell_clip=0.0f, float proj_clip=0.0f, bool merge_outputs=false, bool time_major=true, bool asymmetric_quantize_inputs=false)
Definition schema_generated.h:6639
flatbuffers::Offset< ResizeBilinearOptions > CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, bool align_corners=false, bool half_pixel_centers=false)
Definition schema_generated.h:6710
flatbuffers::Offset< NotEqualOptions > CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8775
flatbuffers::Offset< CastOptions > CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::TensorType in_data_type=tflite::TensorType_FLOAT32, tflite::TensorType out_data_type=tflite::TensorType_FLOAT32)
Definition schema_generated.h:8023
const TensorType(& EnumValuesTensorType())[18]
Definition schema_generated.h:601
flatbuffers::Offset< TensorMap > CreateTensorMap(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::String > name=0, uint32_t tensor_index=0)
Definition schema_generated.h:13014
flatbuffers::Offset< AddNOptions > CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9870
flatbuffers::Offset< MatrixSetDiagOptions > CreateMatrixSetDiagOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10128
flatbuffers::Offset< BidirectionalSequenceRNNOptions > CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, bool time_major=false, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE, bool merge_outputs=false, bool asymmetric_quantize_inputs=false)
Definition schema_generated.h:5881
flatbuffers::Offset< SparseToDenseOptions > CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, bool validate_indices=false)
Definition schema_generated.h:8695
flatbuffers::Offset< MatrixDiagOptions > CreateMatrixDiagOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10050
flatbuffers::Offset< GatherOptions > CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t axis=0, int32_t batch_dims=0)
Definition schema_generated.h:7490
BuiltinOptions
Definition schema_generated.h:1403
@ BuiltinOptions_ReverseV2Options
Definition schema_generated.h:1485
@ BuiltinOptions_StridedSliceOptions
Definition schema_generated.h:1436
@ BuiltinOptions_ConcatenationOptions
Definition schema_generated.h:1414
@ BuiltinOptions_EmbeddingLookupSparseOptions
Definition schema_generated.h:1424
@ BuiltinOptions_CallOptions
Definition schema_generated.h:1420
@ BuiltinOptions_ReshapeOptions
Definition schema_generated.h:1421
@ BuiltinOptions_Conv2DOptions
Definition schema_generated.h:1405
@ BuiltinOptions_LessOptions
Definition schema_generated.h:1445
@ BuiltinOptions_MulOptions
Definition schema_generated.h:1425
@ BuiltinOptions_ArgMinOptions
Definition schema_generated.h:1461
@ BuiltinOptions_RankOptions
Definition schema_generated.h:1490
@ BuiltinOptions_NonMaxSuppressionV4Options
Definition schema_generated.h:1499
@ BuiltinOptions_FullyConnectedOptions
Definition schema_generated.h:1412
@ BuiltinOptions_BatchMatMulOptions
Definition schema_generated.h:1505
@ BuiltinOptions_UnsortedSegmentSumOptions
Definition schema_generated.h:1525
@ BuiltinOptions_VarHandleOptions
Definition schema_generated.h:1515
@ BuiltinOptions_UnpackOptions
Definition schema_generated.h:1468
@ BuiltinOptions_SkipGramOptions
Definition schema_generated.h:1422
@ BuiltinOptions_MatrixSetDiagOptions
Definition schema_generated.h:1494
@ BuiltinOptions_LocalResponseNormalizationOptions
Definition schema_generated.h:1417
@ BuiltinOptions_ReverseSequenceOptions
Definition schema_generated.h:1491
@ BuiltinOptions_AssignVariableOptions
Definition schema_generated.h:1517
@ BuiltinOptions_TransposeConvOptions
Definition schema_generated.h:1453
@ BuiltinOptions_BatchToSpaceNDOptions
Definition schema_generated.h:1428
@ BuiltinOptions_MIN
Definition schema_generated.h:1528
@ BuiltinOptions_HardSwishOptions
Definition schema_generated.h:1495
@ BuiltinOptions_LogicalOrOptions
Definition schema_generated.h:1464
@ BuiltinOptions_UnidirectionalSequenceLSTMOptions
Definition schema_generated.h:1475
@ BuiltinOptions_WhereOptions
Definition schema_generated.h:1489
@ BuiltinOptions_NegOptions
Definition schema_generated.h:1446
@ BuiltinOptions_ZerosLikeOptions
Definition schema_generated.h:1471
@ BuiltinOptions_ReducerOptions
Definition schema_generated.h:1431
@ BuiltinOptions_ATan2Options
Definition schema_generated.h:1526
@ BuiltinOptions_LogSoftmaxOptions
Definition schema_generated.h:1440
@ BuiltinOptions_TransposeOptions
Definition schema_generated.h:1430
@ BuiltinOptions_UnsortedSegmentMinOptions
Definition schema_generated.h:1524
@ BuiltinOptions_MirrorPadOptions
Definition schema_generated.h:1481
@ BuiltinOptions_SignOptions
Definition schema_generated.h:1527
@ BuiltinOptions_HashtableOptions
Definition schema_generated.h:1511
@ BuiltinOptions_ScatterNdOptions
Definition schema_generated.h:1501
@ BuiltinOptions_DensifyOptions
Definition schema_generated.h:1503
@ BuiltinOptions_SoftmaxOptions
Definition schema_generated.h:1413
@ BuiltinOptions_ExpandDimsOptions
Definition schema_generated.h:1456
@ BuiltinOptions_ShapeOptions
Definition schema_generated.h:1459
@ BuiltinOptions_RNNOptions
Definition schema_generated.h:1411
@ BuiltinOptions_RangeOptions
Definition schema_generated.h:1477
@ BuiltinOptions_SquaredDifferenceOptions
Definition schema_generated.h:1480
@ BuiltinOptions_LeakyReluOptions
Definition schema_generated.h:1479
@ BuiltinOptions_DepthToSpaceOptions
Definition schema_generated.h:1498
@ BuiltinOptions_BucketizeOptions
Definition schema_generated.h:1519
@ BuiltinOptions_IfOptions
Definition schema_generated.h:1496
@ BuiltinOptions_NONE
Definition schema_generated.h:1404
@ BuiltinOptions_FloorDivOptions
Definition schema_generated.h:1469
@ BuiltinOptions_LSHProjectionOptions
Definition schema_generated.h:1408
@ BuiltinOptions_FloorModOptions
Definition schema_generated.h:1476
@ BuiltinOptions_MaximumMinimumOptions
Definition schema_generated.h:1443
@ BuiltinOptions_GeluOptions
Definition schema_generated.h:1520
@ BuiltinOptions_DepthwiseConv2DOptions
Definition schema_generated.h:1406
@ BuiltinOptions_ExpOptions
Definition schema_generated.h:1437
@ BuiltinOptions_UnsortedSegmentProdOptions
Definition schema_generated.h:1522
@ BuiltinOptions_UnsortedSegmentMaxOptions
Definition schema_generated.h:1523
@ BuiltinOptions_SquareOptions
Definition schema_generated.h:1470
@ BuiltinOptions_SegmentSumOptions
Definition schema_generated.h:1504
@ BuiltinOptions_QuantizeOptions
Definition schema_generated.h:1493
@ BuiltinOptions_GreaterOptions
Definition schema_generated.h:1448
@ BuiltinOptions_LessEqualOptions
Definition schema_generated.h:1450
@ BuiltinOptions_SqueezeOptions
Definition schema_generated.h:1434
@ BuiltinOptions_SpaceToBatchNDOptions
Definition schema_generated.h:1429
@ BuiltinOptions_SelectV2Options
Definition schema_generated.h:1502
@ BuiltinOptions_OneHotOptions
Definition schema_generated.h:1465
@ BuiltinOptions_CallOnceOptions
Definition schema_generated.h:1507
@ BuiltinOptions_BidirectionalSequenceRNNOptions
Definition schema_generated.h:1474
@ BuiltinOptions_L2NormOptions
Definition schema_generated.h:1416
@ BuiltinOptions_PadOptions
Definition schema_generated.h:1426
@ BuiltinOptions_AddOptions
Definition schema_generated.h:1415
@ BuiltinOptions_GreaterEqualOptions
Definition schema_generated.h:1449
@ BuiltinOptions_ResizeBilinearOptions
Definition schema_generated.h:1419
@ BuiltinOptions_HashtableSizeOptions
Definition schema_generated.h:1514
@ BuiltinOptions_HashtableImportOptions
Definition schema_generated.h:1513
@ BuiltinOptions_Conv3DOptions
Definition schema_generated.h:1510
@ BuiltinOptions_CosOptions
Definition schema_generated.h:1488
@ BuiltinOptions_LSTMOptions
Definition schema_generated.h:1418
@ BuiltinOptions_TopKV2Options
Definition schema_generated.h:1438
@ BuiltinOptions_TileOptions
Definition schema_generated.h:1455
@ BuiltinOptions_ConcatEmbeddingsOptions
Definition schema_generated.h:1407
@ BuiltinOptions_SpaceToDepthOptions
Definition schema_generated.h:1423
@ BuiltinOptions_ArgMaxOptions
Definition schema_generated.h:1444
@ BuiltinOptions_CumsumOptions
Definition schema_generated.h:1506
@ BuiltinOptions_AbsOptions
Definition schema_generated.h:1482
@ BuiltinOptions_Rfft2dOptions
Definition schema_generated.h:1509
@ BuiltinOptions_SliceOptions
Definition schema_generated.h:1452
@ BuiltinOptions_MatrixDiagOptions
Definition schema_generated.h:1492
@ BuiltinOptions_RandomOptions
Definition schema_generated.h:1518
@ BuiltinOptions_FakeQuantOptions
Definition schema_generated.h:1462
@ BuiltinOptions_SequenceRNNOptions
Definition schema_generated.h:1435
@ BuiltinOptions_SelectOptions
Definition schema_generated.h:1451
@ BuiltinOptions_PadV2Options
Definition schema_generated.h:1447
@ BuiltinOptions_GatherNdOptions
Definition schema_generated.h:1487
@ BuiltinOptions_NotEqualOptions
Definition schema_generated.h:1458
@ BuiltinOptions_DequantizeOptions
Definition schema_generated.h:1442
@ BuiltinOptions_DynamicUpdateSliceOptions
Definition schema_generated.h:1521
@ BuiltinOptions_FillOptions
Definition schema_generated.h:1472
@ BuiltinOptions_MAX
Definition schema_generated.h:1529
@ BuiltinOptions_WhileOptions
Definition schema_generated.h:1497
@ BuiltinOptions_SparseToDenseOptions
Definition schema_generated.h:1454
@ BuiltinOptions_Pool2DOptions
Definition schema_generated.h:1409
@ BuiltinOptions_NonMaxSuppressionV5Options
Definition schema_generated.h:1500
@ BuiltinOptions_SVDFOptions
Definition schema_generated.h:1410
@ BuiltinOptions_SplitOptions
Definition schema_generated.h:1439
@ BuiltinOptions_GatherOptions
Definition schema_generated.h:1427
@ BuiltinOptions_CastOptions
Definition schema_generated.h:1441
@ BuiltinOptions_UniqueOptions
Definition schema_generated.h:1484
@ BuiltinOptions_BroadcastToOptions
Definition schema_generated.h:1508
@ BuiltinOptions_ReadVariableOptions
Definition schema_generated.h:1516
@ BuiltinOptions_AddNOptions
Definition schema_generated.h:1486
@ BuiltinOptions_SubOptions
Definition schema_generated.h:1432
@ BuiltinOptions_BidirectionalSequenceLSTMOptions
Definition schema_generated.h:1473
@ BuiltinOptions_PowOptions
Definition schema_generated.h:1460
@ BuiltinOptions_LogicalAndOptions
Definition schema_generated.h:1466
@ BuiltinOptions_HashtableFindOptions
Definition schema_generated.h:1512
@ BuiltinOptions_ResizeNearestNeighborOptions
Definition schema_generated.h:1478
@ BuiltinOptions_LogicalNotOptions
Definition schema_generated.h:1467
@ BuiltinOptions_SplitVOptions
Definition schema_generated.h:1483
@ BuiltinOptions_DivOptions
Definition schema_generated.h:1433
@ BuiltinOptions_EqualOptions
Definition schema_generated.h:1457
@ BuiltinOptions_PackOptions
Definition schema_generated.h:1463
flatbuffers::Offset< LocalResponseNormalizationOptions > CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t radius=0, float bias=0.0f, float alpha=0.0f, float beta=0.0f)
Definition schema_generated.h:6333
const char *const * EnumNamesBuiltinOptions()
Definition schema_generated.h:1662
flatbuffers::Offset< NonMaxSuppressionV4Options > CreateNonMaxSuppressionV4Options(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10345
const char * EnumNameLSTMKernelType(LSTMKernelType e)
Definition schema_generated.h:3969
flatbuffers::Offset< BucketizeOptions > CreateBucketizeOptions(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< float > > boundaries=0)
Definition schema_generated.h:11215
flatbuffers::Offset< PowOptions > CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8905
flatbuffers::Offset< OperatorCode > CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, int8_t deprecated_builtin_code=0, flatbuffers::Offset< flatbuffers::String > custom_code=0, int32_t version=1, tflite::BuiltinOperator builtin_code=tflite::BuiltinOperator_ADD)
Definition schema_generated.h:11629
bool VerifySparseIndexVectorVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector< flatbuffers::Offset< void > > *values, const flatbuffers::Vector< uint8_t > *types)
Definition schema_generated.h:17380
flatbuffers::Offset< ConcatenationOptions > CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t axis=0, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE)
Definition schema_generated.h:6085
flatbuffers::Offset< SqueezeOptions > CreateSqueezeOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int32_t > *squeeze_dims=nullptr)
Definition schema_generated.h:7722
flatbuffers::Offset< LessOptions > CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8365
flatbuffers::Offset< ShapeOptions > CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::TensorType out_type=tflite::TensorType_FLOAT32)
Definition schema_generated.h:8825
const char *const * EnumNamesFullyConnectedOptionsWeightsFormat()
Definition schema_generated.h:3930
Padding
Definition schema_generated.h:3810
@ Padding_MIN
Definition schema_generated.h:3813
@ Padding_VALID
Definition schema_generated.h:3812
@ Padding_SAME
Definition schema_generated.h:3811
@ Padding_MAX
Definition schema_generated.h:3814
flatbuffers::Offset< Conv2DOptions > CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::Padding padding=tflite::Padding_SAME, int32_t stride_w=0, int32_t stride_h=0, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE, int32_t dilation_w_factor=1, int32_t dilation_h_factor=1)
Definition schema_generated.h:5085
const char * EnumNameDimensionType(DimensionType e)
Definition schema_generated.h:769
flatbuffers::Offset< Uint16Vector > CreateUint16VectorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint16_t > *values=nullptr)
Definition schema_generated.h:4395
flatbuffers::Offset< FullyConnectedOptions > CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE, tflite::FullyConnectedOptionsWeightsFormat weights_format=tflite::FullyConnectedOptionsWeightsFormat_DEFAULT, bool keep_num_dims=false, bool asymmetric_quantize_inputs=false)
Definition schema_generated.h:5966
flatbuffers::Offset< OperatorCode > CreateOperatorCodeDirect(flatbuffers::FlatBufferBuilder &_fbb, int8_t deprecated_builtin_code=0, const char *custom_code=nullptr, int32_t version=1, tflite::BuiltinOperator builtin_code=tflite::BuiltinOperator_ADD)
Definition schema_generated.h:11643
flatbuffers::Offset< ResizeNearestNeighborOptions > CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, bool align_corners=false, bool half_pixel_centers=false)
Definition schema_generated.h:6773
flatbuffers::Offset< LessEqualOptions > CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8404
flatbuffers::Offset< ConcatEmbeddingsOptions > CreateConcatEmbeddingsOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb, int32_t num_channels=0, const std::vector< int32_t > *num_columns_per_channel=nullptr, const std::vector< int32_t > *embedding_dim_per_channel=nullptr)
Definition schema_generated.h:5533
flatbuffers::Offset< IfOptions > CreateIfOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t then_subgraph_index=0, int32_t else_subgraph_index=0)
Definition schema_generated.h:10187
flatbuffers::Offset< QuantizationParameters > CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< float > > min=0, flatbuffers::Offset< flatbuffers::Vector< float > > max=0, flatbuffers::Offset< flatbuffers::Vector< float > > scale=0, flatbuffers::Offset< flatbuffers::Vector< int64_t > > zero_point=0, tflite::QuantizationDetails details_type=tflite::QuantizationDetails_NONE, flatbuffers::Offset< void > details=0, int32_t quantized_dimension=0)
Definition schema_generated.h:4236
flatbuffers::Offset< ArgMaxOptions > CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::TensorType output_type=tflite::TensorType_FLOAT32)
Definition schema_generated.h:8194
flatbuffers::Offset< ReverseV2Options > CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9831
flatbuffers::Offset< SignatureDef > CreateSignatureDefDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< flatbuffers::Offset< tflite::TensorMap > > *inputs=nullptr, const std::vector< flatbuffers::Offset< tflite::TensorMap > > *outputs=nullptr, const char *signature_key=nullptr, uint32_t subgraph_index=0)
Definition schema_generated.h:13129
flatbuffers::Offset< LeakyReluOptions > CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, float alpha=0.0f)
Definition schema_generated.h:9647
flatbuffers::Offset< VarHandleOptions > CreateVarHandleOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb, const char *container=nullptr, const char *shared_name=nullptr)
Definition schema_generated.h:11017
const char * ModelExtension()
Definition schema_generated.h:20137
const tflite::Model * GetModel(const void *buf)
Definition schema_generated.h:20105
flatbuffers::Offset< Tensor > CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int32_t > > shape=0, tflite::TensorType type=tflite::TensorType_FLOAT32, uint32_t buffer=0, flatbuffers::Offset< flatbuffers::String > name=0, flatbuffers::Offset< tflite::QuantizationParameters > quantization=0, bool is_variable=false, flatbuffers::Offset< tflite::SparsityParameters > sparsity=0, flatbuffers::Offset< flatbuffers::Vector< int32_t > > shape_signature=0, bool has_rank=false, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::VariantSubType > > > variant_tensors=0)
Definition schema_generated.h:4940
CustomOptionsFormat
Definition schema_generated.h:4038
@ CustomOptionsFormat_FLEXBUFFERS
Definition schema_generated.h:4039
@ CustomOptionsFormat_MIN
Definition schema_generated.h:4040
@ CustomOptionsFormat_MAX
Definition schema_generated.h:4041
const QuantizationDetails(& EnumValuesQuantizationDetails())[2]
Definition schema_generated.h:663
flatbuffers::Offset< NegOptions > CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8443
flatbuffers::Offset< Tensor > CreateTensorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int32_t > *shape=nullptr, tflite::TensorType type=tflite::TensorType_FLOAT32, uint32_t buffer=0, const char *name=nullptr, flatbuffers::Offset< tflite::QuantizationParameters > quantization=0, bool is_variable=false, flatbuffers::Offset< tflite::SparsityParameters > sparsity=0, const std::vector< int32_t > *shape_signature=nullptr, bool has_rank=false, const std::vector< flatbuffers::Offset< tflite::VariantSubType > > *variant_tensors=nullptr)
Definition schema_generated.h:4966
flatbuffers::Offset< Metadata > CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::String > name=0, uint32_t buffer=0)
Definition schema_generated.h:12939
flatbuffers::Offset< EmbeddingLookupSparseOptions > CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::CombinerType combiner=tflite::CombinerType_SUM)
Definition schema_generated.h:7429
flatbuffers::Offset< Int32Vector > CreateInt32VectorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int32_t > *values=nullptr)
Definition schema_generated.h:4333
flatbuffers::Offset< SparsityParameters > CreateSparsityParameters(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int32_t > > traversal_order=0, flatbuffers::Offset< flatbuffers::Vector< int32_t > > block_map=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::DimensionMetadata > > > dim_metadata=0)
Definition schema_generated.h:4689
const char *const * EnumNamesLSTMKernelType()
Definition schema_generated.h:3960
flatbuffers::Offset< LogicalAndOptions > CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9261
const char *const * EnumNamesActivationFunctionType()
Definition schema_generated.h:3863
flatbuffers::Offset< Uint16Vector > CreateUint16Vector(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint16_t > > values=0)
Definition schema_generated.h:4387
flatbuffers::Offset< DimensionMetadata > CreateDimensionMetadata(flatbuffers::FlatBufferBuilder &_fbb, tflite::DimensionType format=tflite::DimensionType_DENSE, int32_t dense_size=0, tflite::SparseIndexVector array_segments_type=tflite::SparseIndexVector_NONE, flatbuffers::Offset< void > array_segments=0, tflite::SparseIndexVector array_indices_type=tflite::SparseIndexVector_NONE, flatbuffers::Offset< void > array_indices=0)
Definition schema_generated.h:4601
flatbuffers::Offset< ExpOptions > CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7572
const char *const * EnumNamesCombinerType()
Definition schema_generated.h:3992
const char * EnumNamePadding(Padding e)
Definition schema_generated.h:3834
flatbuffers::Offset< UnpackOptions > CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t num=0, int32_t axis=0)
Definition schema_generated.h:9359
bool VerifySparseIndexVector(flatbuffers::Verifier &verifier, const void *obj, SparseIndexVector type)
Definition schema_generated.h:17359
flatbuffers::Offset< LSHProjectionOptions > CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::LSHProjectionType type=tflite::LSHProjectionType_UNKNOWN)
Definition schema_generated.h:5591
const CustomOptionsFormat(& EnumValuesCustomOptionsFormat())[1]
Definition schema_generated.h:4044
flatbuffers::Offset< SelectOptions > CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8482
flatbuffers::Offset< ZerosLikeOptions > CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9480
flatbuffers::Offset< CustomQuantization > CreateCustomQuantizationDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint8_t > *custom=nullptr)
Definition schema_generated.h:4116
flatbuffers::Offset< Uint8Vector > CreateUint8VectorDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< uint8_t > *values=nullptr)
Definition schema_generated.h:4458
flatbuffers::Offset< ArgMinOptions > CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::TensorType output_type=tflite::TensorType_FLOAT32)
Definition schema_generated.h:8246
SparseIndexVector
Definition schema_generated.h:775
@ SparseIndexVector_MIN
Definition schema_generated.h:780
@ SparseIndexVector_Uint16Vector
Definition schema_generated.h:778
@ SparseIndexVector_MAX
Definition schema_generated.h:781
@ SparseIndexVector_NONE
Definition schema_generated.h:776
@ SparseIndexVector_Uint8Vector
Definition schema_generated.h:779
@ SparseIndexVector_Int32Vector
Definition schema_generated.h:777
flatbuffers::Offset< DequantizeOptions > CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8066
TensorType
Definition schema_generated.h:578
@ TensorType_STRING
Definition schema_generated.h:584
@ TensorType_INT32
Definition schema_generated.h:581
@ TensorType_MAX
Definition schema_generated.h:598
@ TensorType_RESOURCE
Definition schema_generated.h:592
@ TensorType_UINT8
Definition schema_generated.h:582
@ TensorType_UINT32
Definition schema_generated.h:594
@ TensorType_COMPLEX128
Definition schema_generated.h:590
@ TensorType_FLOAT32
Definition schema_generated.h:579
@ TensorType_INT4
Definition schema_generated.h:596
@ TensorType_BOOL
Definition schema_generated.h:585
@ TensorType_INT16
Definition schema_generated.h:586
@ TensorType_UINT64
Definition schema_generated.h:591
@ TensorType_VARIANT
Definition schema_generated.h:593
@ TensorType_INT8
Definition schema_generated.h:588
@ TensorType_MIN
Definition schema_generated.h:597
@ TensorType_FLOAT64
Definition schema_generated.h:589
@ TensorType_FLOAT16
Definition schema_generated.h:580
@ TensorType_UINT16
Definition schema_generated.h:595
@ TensorType_INT64
Definition schema_generated.h:583
@ TensorType_COMPLEX64
Definition schema_generated.h:587
const char *const * EnumNamesBuiltinOperator()
Definition schema_generated.h:1231
flatbuffers::Offset< Operator > CreateOperatorDirect(flatbuffers::FlatBufferBuilder &_fbb, uint32_t opcode_index=0, const std::vector< int32_t > *inputs=nullptr, const std::vector< int32_t > *outputs=nullptr, tflite::BuiltinOptions builtin_options_type=tflite::BuiltinOptions_NONE, flatbuffers::Offset< void > builtin_options=0, const std::vector< uint8_t > *custom_options=nullptr, tflite::CustomOptionsFormat custom_options_format=tflite::CustomOptionsFormat_FLEXBUFFERS, const std::vector< uint8_t > *mutating_variable_inputs=nullptr, const std::vector< int32_t > *intermediates=nullptr)
Definition schema_generated.h:12665
LSHProjectionType
Definition schema_generated.h:3882
@ LSHProjectionType_MIN
Definition schema_generated.h:3886
@ LSHProjectionType_MAX
Definition schema_generated.h:3887
@ LSHProjectionType_UNKNOWN
Definition schema_generated.h:3883
@ LSHProjectionType_SPARSE
Definition schema_generated.h:3884
@ LSHProjectionType_DENSE
Definition schema_generated.h:3885
flatbuffers::Offset< BroadcastToOptions > CreateBroadcastToOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10716
const CombinerType(& EnumValuesCombinerType())[3]
Definition schema_generated.h:3983
DimensionType
Definition schema_generated.h:745
@ DimensionType_MAX
Definition schema_generated.h:749
@ DimensionType_MIN
Definition schema_generated.h:748
@ DimensionType_DENSE
Definition schema_generated.h:746
@ DimensionType_SPARSE_CSR
Definition schema_generated.h:747
flatbuffers::Offset< SquaredDifferenceOptions > CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9688
flatbuffers::Offset< L2NormOptions > CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE)
Definition schema_generated.h:6254
flatbuffers::Offset< WhileOptions > CreateWhileOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t cond_subgraph_index=0, int32_t body_subgraph_index=0)
Definition schema_generated.h:10302
flatbuffers::Offset< ReshapeOptions > CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int32_t > > new_shape=0)
Definition schema_generated.h:6958
bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type)
Definition schema_generated.h:17472
flatbuffers::Offset< Operator > CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, uint32_t opcode_index=0, flatbuffers::Offset< flatbuffers::Vector< int32_t > > inputs=0, flatbuffers::Offset< flatbuffers::Vector< int32_t > > outputs=0, tflite::BuiltinOptions builtin_options_type=tflite::BuiltinOptions_NONE, flatbuffers::Offset< void > builtin_options=0, flatbuffers::Offset< flatbuffers::Vector< uint8_t > > custom_options=0, tflite::CustomOptionsFormat custom_options_format=tflite::CustomOptionsFormat_FLEXBUFFERS, flatbuffers::Offset< flatbuffers::Vector< uint8_t > > mutating_variable_inputs=0, flatbuffers::Offset< flatbuffers::Vector< int32_t > > intermediates=0)
Definition schema_generated.h:12641
flatbuffers::Offset< CosOptions > CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7611
flatbuffers::Offset< AddOptions > CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE, bool pot_scale_int16=true)
Definition schema_generated.h:6148
flatbuffers::Offset< SubOptions > CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE, bool pot_scale_int16=true)
Definition schema_generated.h:7284
void FinishModelBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset< tflite::Model > root)
Definition schema_generated.h:20141
flatbuffers::Offset< RandomOptions > CreateRandomOptions(flatbuffers::FlatBufferBuilder &_fbb, int64_t seed=0, int64_t seed2=0)
Definition schema_generated.h:11160
const MirrorPadMode(& EnumValuesMirrorPadMode())[2]
Definition schema_generated.h:4015
flatbuffers::Offset< PadV2Options > CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6907
std::unique_ptr< tflite::ModelT > UnPackModel(const void *buf, const flatbuffers::resolver_function_t *res=nullptr)
Definition schema_generated.h:20153
flatbuffers::Offset< SliceOptions > CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8521
flatbuffers::Offset< VariantSubType > CreateVariantSubTypeDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int32_t > *shape=nullptr, tflite::TensorType type=tflite::TensorType_FLOAT32, bool has_rank=false)
Definition schema_generated.h:4791
flatbuffers::Offset< FillOptions > CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9519
flatbuffers::Offset< SoftmaxOptions > CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, float beta=0.0f)
Definition schema_generated.h:6024
flatbuffers::Offset< LogicalNotOptions > CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9300
flatbuffers::Offset< HashtableSizeOptions > CreateHashtableSizeOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10946
flatbuffers::Offset< RangeOptions > CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9597
flatbuffers::Offset< ConcatEmbeddingsOptions > CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t num_channels=0, flatbuffers::Offset< flatbuffers::Vector< int32_t > > num_columns_per_channel=0, flatbuffers::Offset< flatbuffers::Vector< int32_t > > embedding_dim_per_channel=0)
Definition schema_generated.h:5521
flatbuffers::Offset< Pool2DOptions > CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::Padding padding=tflite::Padding_SAME, int32_t stride_w=0, int32_t stride_h=0, int32_t filter_width=0, int32_t filter_height=0, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE)
Definition schema_generated.h:5321
flatbuffers::Offset< Metadata > CreateMetadataDirect(flatbuffers::FlatBufferBuilder &_fbb, const char *name=nullptr, uint32_t buffer=0)
Definition schema_generated.h:12949
flatbuffers::Offset< NonMaxSuppressionV5Options > CreateNonMaxSuppressionV5Options(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10384
const char * EnumNameSparseIndexVector(SparseIndexVector e)
Definition schema_generated.h:805
const char * EnumNameLSHProjectionType(LSHProjectionType e)
Definition schema_generated.h:3909
const char *const * EnumNamesQuantizationDetails()
Definition schema_generated.h:671
bool ModelBufferHasIdentifier(const void *buf)
Definition schema_generated.h:20117
const char *const * EnumNamesPadding()
Definition schema_generated.h:3825
const SparseIndexVector(& EnumValuesSparseIndexVector())[4]
Definition schema_generated.h:784
flatbuffers::Offset< DivOptions > CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE)
Definition schema_generated.h:7338
flatbuffers::Offset< DepthwiseConv2DOptions > CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::Padding padding=tflite::Padding_SAME, int32_t stride_w=0, int32_t stride_h=0, int32_t depth_multiplier=0, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE, int32_t dilation_w_factor=1, int32_t dilation_h_factor=1)
Definition schema_generated.h:5437
const LSHProjectionType(& EnumValuesLSHProjectionType())[3]
Definition schema_generated.h:3890
flatbuffers::Offset< GatherNdOptions > CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9909
flatbuffers::Offset< FakeQuantOptions > CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, float min=0.0f, float max=0.0f, int32_t num_bits=0, bool narrow_range=false)
Definition schema_generated.h:8982
flatbuffers::Offset< Model > CreateModelDirect(flatbuffers::FlatBufferBuilder &_fbb, uint32_t version=0, const std::vector< flatbuffers::Offset< tflite::OperatorCode > > *operator_codes=nullptr, const std::vector< flatbuffers::Offset< tflite::SubGraph > > *subgraphs=nullptr, const char *description=nullptr, const std::vector< flatbuffers::Offset< tflite::Buffer > > *buffers=nullptr, const std::vector< int32_t > *metadata_buffer=nullptr, const std::vector< flatbuffers::Offset< tflite::Metadata > > *metadata=nullptr, const std::vector< flatbuffers::Offset< tflite::SignatureDef > > *signature_defs=nullptr)
Definition schema_generated.h:13291
flatbuffers::Offset< SubGraph > CreateSubGraphDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< flatbuffers::Offset< tflite::Tensor > > *tensors=nullptr, const std::vector< int32_t > *inputs=nullptr, const std::vector< int32_t > *outputs=nullptr, const std::vector< flatbuffers::Offset< tflite::Operator > > *operators=nullptr, const char *name=nullptr)
Definition schema_generated.h:12801
flatbuffers::Offset< SubGraph > CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::Tensor > > > tensors=0, flatbuffers::Offset< flatbuffers::Vector< int32_t > > inputs=0, flatbuffers::Offset< flatbuffers::Vector< int32_t > > outputs=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::Operator > > > operators=0, flatbuffers::Offset< flatbuffers::String > name=0)
Definition schema_generated.h:12785
flatbuffers::Offset< MirrorPadOptions > CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::MirrorPadMode mode=tflite::MirrorPadMode_REFLECT)
Definition schema_generated.h:9738
bool VerifyModelBuffer(flatbuffers::Verifier &verifier)
Definition schema_generated.h:20127
const char * EnumNameCombinerType(CombinerType e)
Definition schema_generated.h:4002
flatbuffers::Offset< Int32Vector > CreateInt32Vector(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int32_t > > values=0)
Definition schema_generated.h:4325
flatbuffers::Offset< WhereOptions > CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9948
flatbuffers::Offset< UnsortedSegmentMinOptions > CreateUnsortedSegmentMinOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11512
flatbuffers::Offset< PackOptions > CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t values_count=0, int32_t axis=0)
Definition schema_generated.h:9049
const char *const * EnumNamesMirrorPadMode()
Definition schema_generated.h:4023
const char * EnumNameActivationFunctionType(ActivationFunctionType e)
Definition schema_generated.h:3876
flatbuffers::Offset< GreaterEqualOptions > CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8326
flatbuffers::Offset< Rfft2dOptions > CreateRfft2dOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10755
flatbuffers::Offset< HashtableImportOptions > CreateHashtableImportOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10907
flatbuffers::Offset< BatchToSpaceNDOptions > CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7047
flatbuffers::Offset< SpaceToBatchNDOptions > CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7008
flatbuffers::Offset< SegmentSumOptions > CreateSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10540
flatbuffers::Offset< Conv3DOptions > CreateConv3DOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::Padding padding=tflite::Padding_SAME, int32_t stride_d=0, int32_t stride_w=0, int32_t stride_h=0, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE, int32_t dilation_d_factor=1, int32_t dilation_w_factor=1, int32_t dilation_h_factor=1)
Definition schema_generated.h:5210
const char * EnumNameQuantizationDetails(QuantizationDetails e)
Definition schema_generated.h:680
const char *const * EnumNamesLSHProjectionType()
Definition schema_generated.h:3899
flatbuffers::Offset< SequenceRNNOptions > CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, bool time_major=false, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE, bool asymmetric_quantize_inputs=false)
Definition schema_generated.h:5798
const char *const * EnumNamesDimensionType()
Definition schema_generated.h:760
std::unique_ptr< tflite::ModelT > UnPackSizePrefixedModel(const void *buf, const flatbuffers::resolver_function_t *res=nullptr)
Definition schema_generated.h:20159
flatbuffers::Offset< ReshapeOptions > CreateReshapeOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int32_t > *new_shape=nullptr)
Definition schema_generated.h:6966
flatbuffers::Offset< CumsumOptions > CreateCumsumOptions(flatbuffers::FlatBufferBuilder &_fbb, bool exclusive=false, bool reverse=false)
Definition schema_generated.h:10673
CombinerType
Definition schema_generated.h:3975
@ CombinerType_SQRTN
Definition schema_generated.h:3978
@ CombinerType_MEAN
Definition schema_generated.h:3977
@ CombinerType_MIN
Definition schema_generated.h:3979
@ CombinerType_SUM
Definition schema_generated.h:3976
@ CombinerType_MAX
Definition schema_generated.h:3980
flatbuffers::Offset< UnsortedSegmentMaxOptions > CreateUnsortedSegmentMaxOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11395
flatbuffers::Offset< MulOptions > CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE)
Definition schema_generated.h:6202
flatbuffers::Offset< ReverseSequenceOptions > CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t seq_dim=0, int32_t batch_dim=0)
Definition schema_generated.h:10007
flatbuffers::Offset< SVDFOptions > CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t rank=0, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE, bool asymmetric_quantize_inputs=false)
Definition schema_generated.h:5661
flatbuffers::Offset< GreaterOptions > CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8287
const BuiltinOptions(& EnumValuesBuiltinOptions())[124]
Definition schema_generated.h:1532
const char * EnumNameCustomOptionsFormat(CustomOptionsFormat e)
Definition schema_generated.h:4059
flatbuffers::Offset< EqualOptions > CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8736
flatbuffers::Offset< TopKV2Options > CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7379
flatbuffers::Offset< DepthToSpaceOptions > CreateDepthToSpaceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t block_size=0)
Definition schema_generated.h:7223
BuiltinOperator
Definition schema_generated.h:902
@ BuiltinOperator_HASHTABLE_LOOKUP
Definition schema_generated.h:913
@ BuiltinOperator_HASHTABLE_SIZE
Definition schema_generated.h:1042
@ BuiltinOperator_LOGICAL_AND
Definition schema_generated.h:989
@ BuiltinOperator_SQUARED_DIFFERENCE
Definition schema_generated.h:1002
@ BuiltinOperator_REDUCE_MIN
Definition schema_generated.h:992
@ BuiltinOperator_PADV2
Definition schema_generated.h:963
@ BuiltinOperator_FAKE_QUANT
Definition schema_generated.h:983
@ BuiltinOperator_READ_VARIABLE
Definition schema_generated.h:1046
@ BuiltinOperator_MAXIMUM
Definition schema_generated.h:958
@ BuiltinOperator_CALL_ONCE
Definition schema_generated.h:1032
@ BuiltinOperator_GREATER_EQUAL
Definition schema_generated.h:965
@ BuiltinOperator_PACK
Definition schema_generated.h:986
@ BuiltinOperator_ELU
Definition schema_generated.h:1014
@ BuiltinOperator_SPARSE_TO_DENSE
Definition schema_generated.h:971
@ BuiltinOperator_CONV_3D_TRANSPOSE
Definition schema_generated.h:1044
@ BuiltinOperator_REDUCE_PROD
Definition schema_generated.h:984
@ BuiltinOperator_LOGISTIC
Definition schema_generated.h:917
@ BuiltinOperator_EMBEDDING_LOOKUP_SPARSE
Definition schema_generated.h:936
@ BuiltinOperator_IF
Definition schema_generated.h:1021
@ BuiltinOperator_UNIQUE
Definition schema_generated.h:1006
@ BuiltinOperator_TOPK_V2
Definition schema_generated.h:951
@ BuiltinOperator_TILE
Definition schema_generated.h:972
@ BuiltinOperator_SELECT
Definition schema_generated.h:967
@ BuiltinOperator_EQUAL
Definition schema_generated.h:974
@ BuiltinOperator_SEGMENT_SUM
Definition schema_generated.h:1028
@ BuiltinOperator_GATHER_ND
Definition schema_generated.h:1010
@ BuiltinOperator_REDUCE_ALL
Definition schema_generated.h:1043
@ BuiltinOperator_EXPAND_DIMS
Definition schema_generated.h:973
@ BuiltinOperator_FLOOR
Definition schema_generated.h:911
@ BuiltinOperator_REAL
Definition schema_generated.h:1037
@ BuiltinOperator_BROADCAST_TO
Definition schema_generated.h:1033
@ BuiltinOperator_HARD_SWISH
Definition schema_generated.h:1020
@ BuiltinOperator_CONV_3D
Definition schema_generated.h:1035
@ BuiltinOperator_UNSORTED_SEGMENT_MIN
Definition schema_generated.h:1060
@ BuiltinOperator_SPLIT
Definition schema_generated.h:952
@ BuiltinOperator_REVERSE_SEQUENCE
Definition schema_generated.h:1015
@ BuiltinOperator_SUM
Definition schema_generated.h:977
@ BuiltinOperator_MIN
Definition schema_generated.h:1062
@ BuiltinOperator_MULTINOMIAL
Definition schema_generated.h:1052
@ BuiltinOperator_SLICE
Definition schema_generated.h:968
@ BuiltinOperator_ADD_N
Definition schema_generated.h:1009
@ BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION
Definition schema_generated.h:916
@ BuiltinOperator_NEG
Definition schema_generated.h:962
@ BuiltinOperator_BROADCAST_ARGS
Definition schema_generated.h:1048
@ BuiltinOperator_ASSIGN_VARIABLE
Definition schema_generated.h:1047
@ BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM
Definition schema_generated.h:947
@ BuiltinOperator_ARG_MIN
Definition schema_generated.h:982
@ BuiltinOperator_SQUARE
Definition schema_generated.h:995
@ BuiltinOperator_CUMSUM
Definition schema_generated.h:1031
@ BuiltinOperator_MAX
Definition schema_generated.h:1063
@ BuiltinOperator_DEQUANTIZE
Definition schema_generated.h:909
@ BuiltinOperator_LEAKY_RELU
Definition schema_generated.h:1001
@ BuiltinOperator_ZEROS_LIKE
Definition schema_generated.h:996
@ BuiltinOperator_RELU
Definition schema_generated.h:922
@ BuiltinOperator_REDUCE_MAX
Definition schema_generated.h:985
@ BuiltinOperator_RESIZE_BILINEAR
Definition schema_generated.h:926
@ BuiltinOperator_SELECT_V2
Definition schema_generated.h:1026
@ BuiltinOperator_CONCATENATION
Definition schema_generated.h:905
@ BuiltinOperator_WHERE
Definition schema_generated.h:1012
@ BuiltinOperator_NON_MAX_SUPPRESSION_V4
Definition schema_generated.h:1023
@ BuiltinOperator_DEPTH_TO_SPACE
Definition schema_generated.h:908
@ BuiltinOperator_RELU_0_TO_1
Definition schema_generated.h:1055
@ BuiltinOperator_LSH_PROJECTION
Definition schema_generated.h:918
@ BuiltinOperator_RESIZE_NEAREST_NEIGHBOR
Definition schema_generated.h:1000
@ BuiltinOperator_REVERSE_V2
Definition schema_generated.h:1008
@ BuiltinOperator_SHAPE
Definition schema_generated.h:980
@ BuiltinOperator_DENSIFY
Definition schema_generated.h:1027
@ BuiltinOperator_LOG
Definition schema_generated.h:976
@ BuiltinOperator_BATCH_MATMUL
Definition schema_generated.h:1029
@ BuiltinOperator_SPACE_TO_BATCH_ND
Definition schema_generated.h:941
@ BuiltinOperator_MUL
Definition schema_generated.h:921
@ BuiltinOperator_CEIL
Definition schema_generated.h:1007
@ BuiltinOperator_CALL
Definition schema_generated.h:934
@ BuiltinOperator_DIV
Definition schema_generated.h:945
@ BuiltinOperator_UNSORTED_SEGMENT_MAX
Definition schema_generated.h:1057
@ BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN
Definition schema_generated.h:949
@ BuiltinOperator_ROUND
Definition schema_generated.h:1019
@ BuiltinOperator_STRIDED_SLICE
Definition schema_generated.h:948
@ BuiltinOperator_RELU_N1_TO_1
Definition schema_generated.h:923
@ BuiltinOperator_MATRIX_DIAG
Definition schema_generated.h:1016
@ BuiltinOperator_TRANSPOSE
Definition schema_generated.h:942
@ BuiltinOperator_TANH
Definition schema_generated.h:931
@ BuiltinOperator_COMPLEX_ABS
Definition schema_generated.h:1038
@ BuiltinOperator_COS
Definition schema_generated.h:1011
@ BuiltinOperator_SKIP_GRAM
Definition schema_generated.h:933
@ BuiltinOperator_AVERAGE_POOL_2D
Definition schema_generated.h:904
@ BuiltinOperator_MEAN
Definition schema_generated.h:943
@ BuiltinOperator_SQRT
Definition schema_generated.h:978
@ BuiltinOperator_HASHTABLE_IMPORT
Definition schema_generated.h:1041
@ BuiltinOperator_MATRIX_SET_DIAG
Definition schema_generated.h:1018
@ BuiltinOperator_WHILE
Definition schema_generated.h:1022
@ BuiltinOperator_PAD
Definition schema_generated.h:937
@ BuiltinOperator_RFFT2D
Definition schema_generated.h:1034
@ BuiltinOperator_ONE_HOT
Definition schema_generated.h:988
@ BuiltinOperator_SPLIT_V
Definition schema_generated.h:1005
@ BuiltinOperator_RNN
Definition schema_generated.h:927
@ BuiltinOperator_FILL
Definition schema_generated.h:997
@ BuiltinOperator_RANK
Definition schema_generated.h:1013
@ BuiltinOperator_NON_MAX_SUPPRESSION_V5
Definition schema_generated.h:1024
@ BuiltinOperator_CONV_2D
Definition schema_generated.h:906
@ BuiltinOperator_SCATTER_ND
Definition schema_generated.h:1025
@ BuiltinOperator_UNSORTED_SEGMENT_SUM
Definition schema_generated.h:1058
@ BuiltinOperator_LSTM
Definition schema_generated.h:919
@ BuiltinOperator_DYNAMIC_UPDATE_SLICE
Definition schema_generated.h:1054
@ BuiltinOperator_ARG_MAX
Definition schema_generated.h:959
@ BuiltinOperator_BUCKETIZE
Definition schema_generated.h:1050
@ BuiltinOperator_HASHTABLE
Definition schema_generated.h:1039
@ BuiltinOperator_FLOOR_MOD
Definition schema_generated.h:998
@ BuiltinOperator_FLOOR_DIV
Definition schema_generated.h:993
@ BuiltinOperator_MINIMUM
Definition schema_generated.h:960
@ BuiltinOperator_IMAG
Definition schema_generated.h:1036
@ BuiltinOperator_RSQRT
Definition schema_generated.h:979
@ BuiltinOperator_TRANSPOSE_CONV
Definition schema_generated.h:970
@ BuiltinOperator_LESS_EQUAL
Definition schema_generated.h:966
@ BuiltinOperator_ADD
Definition schema_generated.h:903
@ BuiltinOperator_RANDOM_STANDARD_NORMAL
Definition schema_generated.h:1049
@ BuiltinOperator_CUSTOM
Definition schema_generated.h:935
@ BuiltinOperator_LOGICAL_NOT
Definition schema_generated.h:990
@ BuiltinOperator_NOT_EQUAL
Definition schema_generated.h:975
@ BuiltinOperator_SIN
Definition schema_generated.h:969
@ BuiltinOperator_DEPTHWISE_CONV_2D
Definition schema_generated.h:907
@ BuiltinOperator_QUANTIZE
Definition schema_generated.h:1017
@ BuiltinOperator_FULLY_CONNECTED
Definition schema_generated.h:912
@ BuiltinOperator_UNSORTED_SEGMENT_PROD
Definition schema_generated.h:1056
@ BuiltinOperator_SIGN
Definition schema_generated.h:1061
@ BuiltinOperator_LOGICAL_OR
Definition schema_generated.h:987
@ BuiltinOperator_RESHAPE
Definition schema_generated.h:925
@ BuiltinOperator_ABS
Definition schema_generated.h:1004
@ BuiltinOperator_BATCH_TO_SPACE_ND
Definition schema_generated.h:940
@ BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN
Definition schema_generated.h:938
@ BuiltinOperator_SOFTMAX
Definition schema_generated.h:928
@ BuiltinOperator_RANDOM_UNIFORM
Definition schema_generated.h:1051
@ BuiltinOperator_MAX_POOL_2D
Definition schema_generated.h:920
@ BuiltinOperator_MIRROR_PAD
Definition schema_generated.h:1003
@ BuiltinOperator_L2_POOL_2D
Definition schema_generated.h:915
@ BuiltinOperator_PRELU
Definition schema_generated.h:957
@ BuiltinOperator_POW
Definition schema_generated.h:981
@ BuiltinOperator_CAST
Definition schema_generated.h:956
@ BuiltinOperator_GELU
Definition schema_generated.h:1053
@ BuiltinOperator_EXP
Definition schema_generated.h:950
@ BuiltinOperator_SVDF
Definition schema_generated.h:930
@ BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM
Definition schema_generated.h:955
@ BuiltinOperator_RELU6
Definition schema_generated.h:924
@ BuiltinOperator_ATAN2
Definition schema_generated.h:1059
@ BuiltinOperator_HASHTABLE_FIND
Definition schema_generated.h:1040
@ BuiltinOperator_SUB
Definition schema_generated.h:944
@ BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES
Definition schema_generated.h:1030
@ BuiltinOperator_RANGE
Definition schema_generated.h:999
@ BuiltinOperator_LOG_SOFTMAX
Definition schema_generated.h:953
@ BuiltinOperator_GATHER
Definition schema_generated.h:939
@ BuiltinOperator_UNPACK
Definition schema_generated.h:991
@ BuiltinOperator_L2_NORMALIZATION
Definition schema_generated.h:914
@ BuiltinOperator_GREATER
Definition schema_generated.h:964
@ BuiltinOperator_SPACE_TO_DEPTH
Definition schema_generated.h:929
@ BuiltinOperator_REDUCE_ANY
Definition schema_generated.h:994
@ BuiltinOperator_DELEGATE
Definition schema_generated.h:954
@ BuiltinOperator_CONCAT_EMBEDDINGS
Definition schema_generated.h:932
@ BuiltinOperator_SQUEEZE
Definition schema_generated.h:946
@ BuiltinOperator_EMBEDDING_LOOKUP
Definition schema_generated.h:910
@ BuiltinOperator_LESS
Definition schema_generated.h:961
@ BuiltinOperator_VAR_HANDLE
Definition schema_generated.h:1045
flatbuffers::Offset< QuantizeOptions > CreateQuantizeOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10089
flatbuffers::Offset< QuantizationParameters > CreateQuantizationParametersDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< float > *min=nullptr, const std::vector< float > *max=nullptr, const std::vector< float > *scale=nullptr, const std::vector< int64_t > *zero_point=nullptr, tflite::QuantizationDetails details_type=tflite::QuantizationDetails_NONE, flatbuffers::Offset< void > details=0, int32_t quantized_dimension=0)
Definition schema_generated.h:4256
const char *const * EnumNamesSparseIndexVector()
Definition schema_generated.h:794
flatbuffers::Offset< AssignVariableOptions > CreateAssignVariableOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11101
QuantizationDetails
Definition schema_generated.h:656
@ QuantizationDetails_MAX
Definition schema_generated.h:660
@ QuantizationDetails_MIN
Definition schema_generated.h:659
@ QuantizationDetails_CustomQuantization
Definition schema_generated.h:658
@ QuantizationDetails_NONE
Definition schema_generated.h:657
flatbuffers::Offset< ATan2Options > CreateATan2Options(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11473
flatbuffers::Offset< RankOptions > CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8866
flatbuffers::Offset< UnsortedSegmentSumOptions > CreateUnsortedSegmentSumOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11434
const ActivationFunctionType(& EnumValuesActivationFunctionType())[6]
Definition schema_generated.h:3851
flatbuffers::Offset< DynamicUpdateSliceOptions > CreateDynamicUpdateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11317
flatbuffers::Offset< SqueezeOptions > CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int32_t > > squeeze_dims=0)
Definition schema_generated.h:7714
flatbuffers::Offset< BatchMatMulOptions > CreateBatchMatMulOptions(flatbuffers::FlatBufferBuilder &_fbb, bool adj_x=false, bool adj_y=false, bool asymmetric_quantize_inputs=false)
Definition schema_generated.h:10608
flatbuffers::Offset< VariantSubType > CreateVariantSubType(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< int32_t > > shape=0, tflite::TensorType type=tflite::TensorType_FLOAT32, bool has_rank=false)
Definition schema_generated.h:4779
flatbuffers::Offset< TensorMap > CreateTensorMapDirect(flatbuffers::FlatBufferBuilder &_fbb, const char *name=nullptr, uint32_t tensor_index=0)
Definition schema_generated.h:13024
flatbuffers::Offset< UniqueOptions > CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::TensorType idx_out_type=tflite::TensorType_INT32)
Definition schema_generated.h:9790
flatbuffers::Offset< AbsOptions > CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9183
const char * EnumNameBuiltinOptions(BuiltinOptions e)
Definition schema_generated.h:1793
flatbuffers::Offset< TransposeOptions > CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7533
LSTMKernelType
Definition schema_generated.h:3945
@ LSTMKernelType_MAX
Definition schema_generated.h:3949
@ LSTMKernelType_MIN
Definition schema_generated.h:3948
@ LSTMKernelType_FULL
Definition schema_generated.h:3946
@ LSTMKernelType_BASIC
Definition schema_generated.h:3947
flatbuffers::Offset< TransposeConvOptions > CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::Padding padding=tflite::Padding_SAME, int32_t stride_w=0, int32_t stride_h=0, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE)
Definition schema_generated.h:8598
flatbuffers::Offset< RNNOptions > CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE, bool asymmetric_quantize_inputs=false)
Definition schema_generated.h:5726
flatbuffers::Offset< TileOptions > CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8144
bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector< flatbuffers::Offset< void > > *values, const flatbuffers::Vector< uint8_t > *types)
Definition schema_generated.h:17301
flatbuffers::Offset< OneHotOptions > CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t axis=0)
Definition schema_generated.h:9142
flatbuffers::Offset< Uint8Vector > CreateUint8Vector(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint8_t > > values=0)
Definition schema_generated.h:4450
flatbuffers::Offset< LogSoftmaxOptions > CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7964
const char * EnumNameFullyConnectedOptionsWeightsFormat(FullyConnectedOptionsWeightsFormat e)
Definition schema_generated.h:3939
bool VerifySizePrefixedModelBuffer(flatbuffers::Verifier &verifier)
Definition schema_generated.h:20132
flatbuffers::Offset< PadOptions > CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6868
flatbuffers::Offset< FloorModOptions > CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9558
flatbuffers::Offset< ReadVariableOptions > CreateReadVariableOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11062
flatbuffers::Offset< HashtableFindOptions > CreateHashtableFindOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10868
ActivationFunctionType
Definition schema_generated.h:3840
@ ActivationFunctionType_NONE
Definition schema_generated.h:3841
@ ActivationFunctionType_RELU6
Definition schema_generated.h:3844
@ ActivationFunctionType_TANH
Definition schema_generated.h:3845
@ ActivationFunctionType_RELU_N1_TO_1
Definition schema_generated.h:3843
@ ActivationFunctionType_MAX
Definition schema_generated.h:3848
@ ActivationFunctionType_SIGN_BIT
Definition schema_generated.h:3846
@ ActivationFunctionType_RELU
Definition schema_generated.h:3842
@ ActivationFunctionType_MIN
Definition schema_generated.h:3847
flatbuffers::Offset< SparsityParameters > CreateSparsityParametersDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< int32_t > *traversal_order=nullptr, const std::vector< int32_t > *block_map=nullptr, const std::vector< flatbuffers::Offset< tflite::DimensionMetadata > > *dim_metadata=nullptr)
Definition schema_generated.h:4701
flatbuffers::Offset< HashtableOptions > CreateHashtableOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t table_id=0, tflite::TensorType key_dtype=tflite::TensorType_FLOAT32, tflite::TensorType value_dtype=tflite::TensorType_FLOAT32)
Definition schema_generated.h:10823
flatbuffers::Offset< UnsortedSegmentProdOptions > CreateUnsortedSegmentProdOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11356
const FullyConnectedOptionsWeightsFormat(& EnumValuesFullyConnectedOptionsWeightsFormat())[2]
Definition schema_generated.h:3922
flatbuffers::Offset< ExpandDimsOptions > CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8645
flatbuffers::Offset< SignatureDef > CreateSignatureDef(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::TensorMap > > > inputs=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::TensorMap > > > outputs=0, flatbuffers::Offset< flatbuffers::String > signature_key=0, uint32_t subgraph_index=0)
Definition schema_generated.h:13115
const tflite::Model * GetSizePrefixedModel(const void *buf)
Definition schema_generated.h:20109
const char * EnumNameBuiltinOperator(BuiltinOperator e)
Definition schema_generated.h:1397
flatbuffers::Offset< UnidirectionalSequenceLSTMOptions > CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE, float cell_clip=0.0f, float proj_clip=0.0f, bool time_major=false, bool asymmetric_quantize_inputs=false, bool diagonal_recurrent_tensors=false)
Definition schema_generated.h:6532
flatbuffers::Offset< HardSwishOptions > CreateHardSwishOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9222
flatbuffers::Offset< LSTMOptions > CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, tflite::ActivationFunctionType fused_activation_function=tflite::ActivationFunctionType_NONE, float cell_clip=0.0f, float proj_clip=0.0f, tflite::LSTMKernelType kernel_type=tflite::LSTMKernelType_FULL, bool asymmetric_quantize_inputs=false)
Definition schema_generated.h:6427
flatbuffers::Offset< VarHandleOptions > CreateVarHandleOptions(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::String > container=0, flatbuffers::Offset< flatbuffers::String > shared_name=0)
Definition schema_generated.h:11007
flatbuffers::Offset< GeluOptions > CreateGeluOptions(flatbuffers::FlatBufferBuilder &_fbb, bool approximate=false)
Definition schema_generated.h:11276
const char *const * EnumNamesCustomOptionsFormat()
Definition schema_generated.h:4051
flatbuffers::Offset< CallOptions > CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, uint32_t subgraph=0)
Definition schema_generated.h:6827
flatbuffers::Offset< MaximumMinimumOptions > CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8105
flatbuffers::Offset< StridedSliceOptions > CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t begin_mask=0, int32_t end_mask=0, int32_t ellipsis_mask=0, int32_t new_axis_mask=0, int32_t shrink_axis_mask=0)
Definition schema_generated.h:7915
const BuiltinOperator(& EnumValuesBuiltinOperator())[159]
Definition schema_generated.h:1066
const char * ModelIdentifier()
Definition schema_generated.h:20113
const char * EnumNameTensorType(TensorType e)
Definition schema_generated.h:650
bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector< flatbuffers::Offset< void > > *values, const flatbuffers::Vector< uint8_t > *types)
Definition schema_generated.h:17973
const LSTMKernelType(& EnumValuesLSTMKernelType())[2]
Definition schema_generated.h:3952
const char * EnumNameMirrorPadMode(MirrorPadMode e)
Definition schema_generated.h:4032
FullyConnectedOptionsWeightsFormat
Definition schema_generated.h:3915
@ FullyConnectedOptionsWeightsFormat_MIN
Definition schema_generated.h:3918
@ FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8
Definition schema_generated.h:3917
@ FullyConnectedOptionsWeightsFormat_MAX
Definition schema_generated.h:3919
@ FullyConnectedOptionsWeightsFormat_DEFAULT
Definition schema_generated.h:3916
flatbuffers::Offset< ScatterNdOptions > CreateScatterNdOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10423
flatbuffers::Offset< FloorDivOptions > CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9402
const DimensionType(& EnumValuesDimensionType())[2]
Definition schema_generated.h:752
flatbuffers::Offset< SplitVOptions > CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t num_splits=0)
Definition schema_generated.h:7827
void FinishSizePrefixedModelBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset< tflite::Model > root)
Definition schema_generated.h:20147
flatbuffers::Offset< LogicalOrOptions > CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9092
bool SizePrefixedModelBufferHasIdentifier(const void *buf)
Definition schema_generated.h:20122
flatbuffers::Offset< SpaceToDepthOptions > CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t block_size=0)
Definition schema_generated.h:7171
flatbuffers::Offset< BucketizeOptions > CreateBucketizeOptionsDirect(flatbuffers::FlatBufferBuilder &_fbb, const std::vector< float > *boundaries=nullptr)
Definition schema_generated.h:11223
flatbuffers::Offset< CustomQuantization > CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint8_t > > custom=0)
Definition schema_generated.h:4108
flatbuffers::Offset< SquareOptions > CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9441
flatbuffers::Offset< SkipGramOptions > CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t ngram_size=0, int32_t max_skip_size=0, bool include_all_ngrams=false)
Definition schema_generated.h:7115
const Padding(& EnumValuesPadding())[2]
Definition schema_generated.h:3817
flatbuffers::Offset< ReducerOptions > CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, bool keep_dims=false)
Definition schema_generated.h:7661
flatbuffers::Offset< SplitOptions > CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t num_splits=0)
Definition schema_generated.h:7775
flatbuffers::Offset< DensifyOptions > CreateDensifyOptions(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10501
flatbuffers::Offset< Buffer > CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset< flatbuffers::Vector< uint8_t > > data=0)
Definition schema_generated.h:12867
flatbuffers::Offset< SelectV2Options > CreateSelectV2Options(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10462
MirrorPadMode
Definition schema_generated.h:4008
@ MirrorPadMode_SYMMETRIC
Definition schema_generated.h:4010
@ MirrorPadMode_REFLECT
Definition schema_generated.h:4009
@ MirrorPadMode_MAX
Definition schema_generated.h:4012
@ MirrorPadMode_MIN
Definition schema_generated.h:4011
flatbuffers::Offset< CallOnceOptions > CreateCallOnceOptions(flatbuffers::FlatBufferBuilder &_fbb, int32_t init_subgraph_index=0)
Definition schema_generated.h:10241
flatbuffers::Offset< Model > CreateModel(flatbuffers::FlatBufferBuilder &_fbb, uint32_t version=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::OperatorCode > > > operator_codes=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::SubGraph > > > subgraphs=0, flatbuffers::Offset< flatbuffers::String > description=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::Buffer > > > buffers=0, flatbuffers::Offset< flatbuffers::Vector< int32_t > > metadata_buffer=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::Metadata > > > metadata=0, flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::SignatureDef > > > signature_defs=0)
Definition schema_generated.h:13269
int32_t num_channels
Definition stacker.cc:42
TfLiteTensor * end
Definition strided_slice.cpp:60
Definition layer_by_layer_schema_generated.h:102
Definition flatbuffers.h:84
Definition string.h:25
Definition schema_generated.h:14188
ATan2Options Table
Definition schema_generated.h:11459
flatbuffers::uoffset_t start_
Definition schema_generated.h:11461
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:11460
ATan2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11462
flatbuffers::Offset< ATan2Options > Finish()
Definition schema_generated.h:11466
Definition schema_generated.h:14172
ATan2Options TableType
Definition schema_generated.h:11443
Definition schema_generated.h:11898
AbsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9172
flatbuffers::uoffset_t start_
Definition schema_generated.h:9171
AbsOptions Table
Definition schema_generated.h:9169
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9170
flatbuffers::Offset< AbsOptions > Finish()
Definition schema_generated.h:9176
Definition schema_generated.h:11882
AbsOptions TableType
Definition schema_generated.h:9153
Definition schema_generated.h:12585
flatbuffers::Offset< AddNOptions > Finish()
Definition schema_generated.h:9863
flatbuffers::uoffset_t start_
Definition schema_generated.h:9858
AddNOptions Table
Definition schema_generated.h:9856
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9857
AddNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9859
Definition schema_generated.h:12569
AddNOptions TableType
Definition schema_generated.h:9840
Definition schema_generated.h:8835
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:6131
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6129
AddOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6137
void add_pot_scale_int16(bool pot_scale_int16)
Definition schema_generated.h:6134
flatbuffers::uoffset_t start_
Definition schema_generated.h:6130
flatbuffers::Offset< AddOptions > Finish()
Definition schema_generated.h:6141
AddOptions Table
Definition schema_generated.h:6128
Definition schema_generated.h:8805
AddOptions TableType
Definition schema_generated.h:6098
Definition schema_generated.h:10895
flatbuffers::Offset< ArgMaxOptions > Finish()
Definition schema_generated.h:8187
ArgMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8183
ArgMaxOptions Table
Definition schema_generated.h:8177
void add_output_type(tflite::TensorType output_type)
Definition schema_generated.h:8180
flatbuffers::uoffset_t start_
Definition schema_generated.h:8179
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8178
Definition schema_generated.h:10871
ArgMaxOptions TableType
Definition schema_generated.h:8153
Definition schema_generated.h:10947
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8230
ArgMinOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8235
ArgMinOptions Table
Definition schema_generated.h:8229
void add_output_type(tflite::TensorType output_type)
Definition schema_generated.h:8232
flatbuffers::uoffset_t start_
Definition schema_generated.h:8231
flatbuffers::Offset< ArgMinOptions > Finish()
Definition schema_generated.h:8239
Definition schema_generated.h:10923
ArgMinOptions TableType
Definition schema_generated.h:8205
Definition schema_generated.h:13816
flatbuffers::Offset< AssignVariableOptions > Finish()
Definition schema_generated.h:11094
AssignVariableOptions Table
Definition schema_generated.h:11087
flatbuffers::uoffset_t start_
Definition schema_generated.h:11089
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:11088
AssignVariableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11090
Definition schema_generated.h:13800
AssignVariableOptions TableType
Definition schema_generated.h:11071
Definition schema_generated.h:13314
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10586
void add_adj_x(bool adj_x)
Definition schema_generated.h:10588
void add_adj_y(bool adj_y)
Definition schema_generated.h:10591
BatchMatMulOptions Table
Definition schema_generated.h:10585
BatchMatMulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10597
flatbuffers::uoffset_t start_
Definition schema_generated.h:10587
flatbuffers::Offset< BatchMatMulOptions > Finish()
Definition schema_generated.h:10601
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
Definition schema_generated.h:10594
Definition schema_generated.h:13278
BatchMatMulOptions TableType
Definition schema_generated.h:10549
Definition schema_generated.h:9740
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7034
flatbuffers::uoffset_t start_
Definition schema_generated.h:7035
BatchToSpaceNDOptions Table
Definition schema_generated.h:7033
BatchToSpaceNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7036
flatbuffers::Offset< BatchToSpaceNDOptions > Finish()
Definition schema_generated.h:7040
Definition schema_generated.h:9724
BatchToSpaceNDOptions TableType
Definition schema_generated.h:7017
Definition schema_generated.h:9314
void add_merge_outputs(bool merge_outputs)
Definition schema_generated.h:6619
void add_cell_clip(float cell_clip)
Definition schema_generated.h:6613
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6608
BidirectionalSequenceLSTMOptions Table
Definition schema_generated.h:6607
void add_time_major(bool time_major)
Definition schema_generated.h:6622
BidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6628
flatbuffers::Offset< BidirectionalSequenceLSTMOptions > Finish()
Definition schema_generated.h:6632
flatbuffers::uoffset_t start_
Definition schema_generated.h:6609
void add_proj_clip(float proj_clip)
Definition schema_generated.h:6616
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
Definition schema_generated.h:6625
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:6610
Definition schema_generated.h:9260
BidirectionalSequenceLSTMOptions TableType
Definition schema_generated.h:6553
Definition schema_generated.h:8551
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:5856
void add_merge_outputs(bool merge_outputs)
Definition schema_generated.h:5864
BidirectionalSequenceRNNOptions Table
Definition schema_generated.h:5855
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:5861
void add_time_major(bool time_major)
Definition schema_generated.h:5858
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
Definition schema_generated.h:5867
flatbuffers::Offset< BidirectionalSequenceRNNOptions > Finish()
Definition schema_generated.h:5874
BidirectionalSequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:5870
flatbuffers::uoffset_t start_
Definition schema_generated.h:5857
Definition schema_generated.h:8509
BidirectionalSequenceRNNOptions TableType
Definition schema_generated.h:5813
Definition schema_generated.h:13431
BroadcastToOptions Table
Definition schema_generated.h:10702
flatbuffers::Offset< BroadcastToOptions > Finish()
Definition schema_generated.h:10709
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10703
BroadcastToOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10705
flatbuffers::uoffset_t start_
Definition schema_generated.h:10704
Definition schema_generated.h:13415
BroadcastToOptions TableType
Definition schema_generated.h:10686
Definition schema_generated.h:13927
BucketizeOptions Table
Definition schema_generated.h:11198
BucketizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11204
void add_boundaries(flatbuffers::Offset< flatbuffers::Vector< float > > boundaries)
Definition schema_generated.h:11201
flatbuffers::uoffset_t start_
Definition schema_generated.h:11200
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:11199
flatbuffers::Offset< BucketizeOptions > Finish()
Definition schema_generated.h:11208
Definition schema_generated.h:13902
BucketizeOptions TableType
Definition schema_generated.h:11173
Definition schema_generated.h:16013
flatbuffers::Offset< Buffer > Finish()
Definition schema_generated.h:12860
flatbuffers::uoffset_t start_
Definition schema_generated.h:12852
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:12851
void add_data(flatbuffers::Offset< flatbuffers::Vector< uint8_t > > data)
Definition schema_generated.h:12853
Buffer Table
Definition schema_generated.h:12850
BufferBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:12856
Definition schema_generated.h:15976
Buffer TableType
Definition schema_generated.h:12825
Definition schema_generated.h:2041
static const BuiltinOptions enum_value
Definition schema_generated.h:1800
Definition schema_generated.h:3057
const tflite::CallOnceOptionsT * AsCallOnceOptions() const
Definition schema_generated.h:3641
const tflite::WhileOptionsT * AsWhileOptions() const
Definition schema_generated.h:3561
const tflite::WhereOptionsT * AsWhereOptions() const
Definition schema_generated.h:3497
BuiltinOptions type
Definition schema_generated.h:2792
const tflite::LeakyReluOptionsT * AsLeakyReluOptions() const
Definition schema_generated.h:3417
const tflite::ATan2OptionsT * AsATan2Options() const
Definition schema_generated.h:3793
const tflite::SegmentSumOptionsT * AsSegmentSumOptions() const
Definition schema_generated.h:3617
const tflite::HashtableOptionsT * AsHashtableOptions() const
Definition schema_generated.h:3673
const tflite::NonMaxSuppressionV4OptionsT * AsNonMaxSuppressionV4Options() const
Definition schema_generated.h:3577
tflite::NonMaxSuppressionV5OptionsT * AsNonMaxSuppressionV5Options()
Definition schema_generated.h:3581
tflite::PadV2OptionsT * AsPadV2Options()
Definition schema_generated.h:3157
const tflite::CosOptionsT * AsCosOptions() const
Definition schema_generated.h:3489
tflite::GatherOptionsT * AsGatherOptions()
Definition schema_generated.h:2997
tflite::LogicalOrOptionsT * AsLogicalOrOptions()
Definition schema_generated.h:3293
const tflite::ExpOptionsT * AsExpOptions() const
Definition schema_generated.h:3081
tflite::LSHProjectionOptionsT * AsLSHProjectionOptions()
Definition schema_generated.h:2845
tflite::Conv3DOptionsT * AsConv3DOptions()
Definition schema_generated.h:3661
tflite::MatrixDiagOptionsT * AsMatrixDiagOptions()
Definition schema_generated.h:3517
const tflite::HashtableFindOptionsT * AsHashtableFindOptions() const
Definition schema_generated.h:3681
tflite::L2NormOptionsT * AsL2NormOptions()
Definition schema_generated.h:2909
tflite::LessOptionsT * AsLessOptions()
Definition schema_generated.h:3141
tflite::GeluOptionsT * AsGeluOptions()
Definition schema_generated.h:3741
tflite::LogicalAndOptionsT * AsLogicalAndOptions()
Definition schema_generated.h:3309
tflite::ArgMinOptionsT * AsArgMinOptions()
Definition schema_generated.h:3269
const tflite::AddNOptionsT * AsAddNOptions() const
Definition schema_generated.h:3473
tflite::DequantizeOptionsT * AsDequantizeOptions()
Definition schema_generated.h:3117
const tflite::ShapeOptionsT * AsShapeOptions() const
Definition schema_generated.h:3257
const tflite::ResizeNearestNeighborOptionsT * AsResizeNearestNeighborOptions() const
Definition schema_generated.h:3409
tflite::LogSoftmaxOptionsT * AsLogSoftmaxOptions()
Definition schema_generated.h:3101
const tflite::SliceOptionsT * AsSliceOptions() const
Definition schema_generated.h:3201
const tflite::DynamicUpdateSliceOptionsT * AsDynamicUpdateSliceOptions() const
Definition schema_generated.h:3753
const tflite::RankOptionsT * AsRankOptions() const
Definition schema_generated.h:3505
tflite::ReshapeOptionsT * AsReshapeOptions()
Definition schema_generated.h:2949
tflite::GatherNdOptionsT * AsGatherNdOptions()
Definition schema_generated.h:3477
tflite::AssignVariableOptionsT * AsAssignVariableOptions()
Definition schema_generated.h:3717
const tflite::ScatterNdOptionsT * AsScatterNdOptions() const
Definition schema_generated.h:3593
const tflite::AbsOptionsT * AsAbsOptions() const
Definition schema_generated.h:3441
const tflite::LessEqualOptionsT * AsLessEqualOptions() const
Definition schema_generated.h:3185
tflite::BatchMatMulOptionsT * AsBatchMatMulOptions()
Definition schema_generated.h:3621
tflite::SparseToDenseOptionsT * AsSparseToDenseOptions()
Definition schema_generated.h:3213
tflite::BroadcastToOptionsT * AsBroadcastToOptions()
Definition schema_generated.h:3645
tflite::PowOptionsT * AsPowOptions()
Definition schema_generated.h:3261
tflite::SpaceToBatchNDOptionsT * AsSpaceToBatchNDOptions()
Definition schema_generated.h:3013
const tflite::UnpackOptionsT * AsUnpackOptions() const
Definition schema_generated.h:3329
const tflite::AddOptionsT * AsAddOptions() const
Definition schema_generated.h:2905
const tflite::Pool2DOptionsT * AsPool2DOptions() const
Definition schema_generated.h:2857
const tflite::ArgMinOptionsT * AsArgMinOptions() const
Definition schema_generated.h:3273
tflite::EmbeddingLookupSparseOptionsT * AsEmbeddingLookupSparseOptions()
Definition schema_generated.h:2973
const tflite::HashtableSizeOptionsT * AsHashtableSizeOptions() const
Definition schema_generated.h:3697
tflite::SpaceToDepthOptionsT * AsSpaceToDepthOptions()
Definition schema_generated.h:2965
tflite::SelectOptionsT * AsSelectOptions()
Definition schema_generated.h:3189
tflite::HashtableOptionsT * AsHashtableOptions()
Definition schema_generated.h:3669
const tflite::RandomOptionsT * AsRandomOptions() const
Definition schema_generated.h:3729
const tflite::UnsortedSegmentProdOptionsT * AsUnsortedSegmentProdOptions() const
Definition schema_generated.h:3761
tflite::RangeOptionsT * AsRangeOptions()
Definition schema_generated.h:3397
tflite::FullyConnectedOptionsT * AsFullyConnectedOptions()
Definition schema_generated.h:2877
const tflite::DepthToSpaceOptionsT * AsDepthToSpaceOptions() const
Definition schema_generated.h:3569
const tflite::PadOptionsT * AsPadOptions() const
Definition schema_generated.h:2993
const tflite::SplitOptionsT * AsSplitOptions() const
Definition schema_generated.h:3097
const tflite::LSTMOptionsT * AsLSTMOptions() const
Definition schema_generated.h:2929
tflite::LogicalNotOptionsT * AsLogicalNotOptions()
Definition schema_generated.h:3317
tflite::SplitVOptionsT * AsSplitVOptions()
Definition schema_generated.h:3445
const tflite::SpaceToBatchNDOptionsT * AsSpaceToBatchNDOptions() const
Definition schema_generated.h:3017
tflite::HardSwishOptionsT * AsHardSwishOptions()
Definition schema_generated.h:3541
const tflite::MirrorPadOptionsT * AsMirrorPadOptions() const
Definition schema_generated.h:3433
tflite::ExpandDimsOptionsT * AsExpandDimsOptions()
Definition schema_generated.h:3229
tflite::UnidirectionalSequenceLSTMOptionsT * AsUnidirectionalSequenceLSTMOptions()
Definition schema_generated.h:3381
const tflite::GreaterOptionsT * AsGreaterOptions() const
Definition schema_generated.h:3169
const tflite::Rfft2dOptionsT * AsRfft2dOptions() const
Definition schema_generated.h:3657
tflite::SVDFOptionsT * AsSVDFOptions()
Definition schema_generated.h:2861
const tflite::GatherOptionsT * AsGatherOptions() const
Definition schema_generated.h:3001
const tflite::OneHotOptionsT * AsOneHotOptions() const
Definition schema_generated.h:3305
const tflite::StridedSliceOptionsT * AsStridedSliceOptions() const
Definition schema_generated.h:3073
const tflite::SplitVOptionsT * AsSplitVOptions() const
Definition schema_generated.h:3449
const tflite::ZerosLikeOptionsT * AsZerosLikeOptions() const
Definition schema_generated.h:3353
tflite::CumsumOptionsT * AsCumsumOptions()
Definition schema_generated.h:3629
tflite::ZerosLikeOptionsT * AsZerosLikeOptions()
Definition schema_generated.h:3349
const tflite::BroadcastToOptionsT * AsBroadcastToOptions() const
Definition schema_generated.h:3649
tflite::TopKV2OptionsT * AsTopKV2Options()
Definition schema_generated.h:3085
const tflite::ArgMaxOptionsT * AsArgMaxOptions() const
Definition schema_generated.h:3137
tflite::MulOptionsT * AsMulOptions()
Definition schema_generated.h:2981
const tflite::LogSoftmaxOptionsT * AsLogSoftmaxOptions() const
Definition schema_generated.h:3105
tflite::ResizeBilinearOptionsT * AsResizeBilinearOptions()
Definition schema_generated.h:2933
tflite::DensifyOptionsT * AsDensifyOptions()
Definition schema_generated.h:3605
flatbuffers::Offset< void > Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher=nullptr) const
Definition schema_generated.h:18484
tflite::BucketizeOptionsT * AsBucketizeOptions()
Definition schema_generated.h:3733
const tflite::NonMaxSuppressionV5OptionsT * AsNonMaxSuppressionV5Options() const
Definition schema_generated.h:3585
const tflite::ConcatenationOptionsT * AsConcatenationOptions() const
Definition schema_generated.h:2897
tflite::FillOptionsT * AsFillOptions()
Definition schema_generated.h:3357
tflite::UnsortedSegmentSumOptionsT * AsUnsortedSegmentSumOptions()
Definition schema_generated.h:3781
tflite::DynamicUpdateSliceOptionsT * AsDynamicUpdateSliceOptions()
Definition schema_generated.h:3749
tflite::GreaterOptionsT * AsGreaterOptions()
Definition schema_generated.h:3165
tflite::ReadVariableOptionsT * AsReadVariableOptions()
Definition schema_generated.h:3709
tflite::PackOptionsT * AsPackOptions()
Definition schema_generated.h:3285
const tflite::SoftmaxOptionsT * AsSoftmaxOptions() const
Definition schema_generated.h:2889
tflite::MirrorPadOptionsT * AsMirrorPadOptions()
Definition schema_generated.h:3429
const tflite::UnidirectionalSequenceLSTMOptionsT * AsUnidirectionalSequenceLSTMOptions() const
Definition schema_generated.h:3385
tflite::AbsOptionsT * AsAbsOptions()
Definition schema_generated.h:3437
const tflite::FakeQuantOptionsT * AsFakeQuantOptions() const
Definition schema_generated.h:3281
tflite::SubOptionsT * AsSubOptions()
Definition schema_generated.h:3037
tflite::UnsortedSegmentMaxOptionsT * AsUnsortedSegmentMaxOptions()
Definition schema_generated.h:3765
tflite::RNNOptionsT * AsRNNOptions()
Definition schema_generated.h:2869
const tflite::MatrixDiagOptionsT * AsMatrixDiagOptions() const
Definition schema_generated.h:3521
const tflite::DepthwiseConv2DOptionsT * AsDepthwiseConv2DOptions() const
Definition schema_generated.h:2833
tflite::TileOptionsT * AsTileOptions()
Definition schema_generated.h:3221
tflite::UniqueOptionsT * AsUniqueOptions()
Definition schema_generated.h:3453
tflite::CallOptionsT * AsCallOptions()
Definition schema_generated.h:2941
tflite::DepthToSpaceOptionsT * AsDepthToSpaceOptions()
Definition schema_generated.h:3565
BuiltinOptionsUnion()
Definition schema_generated.h:2795
tflite::ConcatEmbeddingsOptionsT * AsConcatEmbeddingsOptions()
Definition schema_generated.h:2837
const tflite::Conv2DOptionsT * AsConv2DOptions() const
Definition schema_generated.h:2825
tflite::UnsortedSegmentMinOptionsT * AsUnsortedSegmentMinOptions()
Definition schema_generated.h:3773
BuiltinOptionsUnion(BuiltinOptionsUnion &&u) FLATBUFFERS_NOEXCEPT
Definition schema_generated.h:2796
const tflite::UnsortedSegmentMinOptionsT * AsUnsortedSegmentMinOptions() const
Definition schema_generated.h:3777
tflite::LocalResponseNormalizationOptionsT * AsLocalResponseNormalizationOptions()
Definition schema_generated.h:2917
const tflite::ReshapeOptionsT * AsReshapeOptions() const
Definition schema_generated.h:2953
const tflite::FloorDivOptionsT * AsFloorDivOptions() const
Definition schema_generated.h:3337
const tflite::MatrixSetDiagOptionsT * AsMatrixSetDiagOptions() const
Definition schema_generated.h:3537
const tflite::MaximumMinimumOptionsT * AsMaximumMinimumOptions() const
Definition schema_generated.h:3129
const tflite::SquareOptionsT * AsSquareOptions() const
Definition schema_generated.h:3345
const tflite::EmbeddingLookupSparseOptionsT * AsEmbeddingLookupSparseOptions() const
Definition schema_generated.h:2977
tflite::MatrixSetDiagOptionsT * AsMatrixSetDiagOptions()
Definition schema_generated.h:3533
const tflite::NotEqualOptionsT * AsNotEqualOptions() const
Definition schema_generated.h:3249
const tflite::SignOptionsT * AsSignOptions() const
Definition schema_generated.h:3801
const tflite::TransposeConvOptionsT * AsTransposeConvOptions() const
Definition schema_generated.h:3209
const tflite::SequenceRNNOptionsT * AsSequenceRNNOptions() const
Definition schema_generated.h:3065
const tflite::LSHProjectionOptionsT * AsLSHProjectionOptions() const
Definition schema_generated.h:2849
tflite::ShapeOptionsT * AsShapeOptions()
Definition schema_generated.h:3253
const tflite::ReverseV2OptionsT * AsReverseV2Options() const
Definition schema_generated.h:3465
const tflite::RangeOptionsT * AsRangeOptions() const
Definition schema_generated.h:3401
tflite::PadOptionsT * AsPadOptions()
Definition schema_generated.h:2989
~BuiltinOptionsUnion()
Definition schema_generated.h:2804
const tflite::SparseToDenseOptionsT * AsSparseToDenseOptions() const
Definition schema_generated.h:3217
const tflite::DequantizeOptionsT * AsDequantizeOptions() const
Definition schema_generated.h:3121
const tflite::QuantizeOptionsT * AsQuantizeOptions() const
Definition schema_generated.h:3529
const tflite::SelectOptionsT * AsSelectOptions() const
Definition schema_generated.h:3193
const tflite::SVDFOptionsT * AsSVDFOptions() const
Definition schema_generated.h:2865
const tflite::Conv3DOptionsT * AsConv3DOptions() const
Definition schema_generated.h:3665
const tflite::ConcatEmbeddingsOptionsT * AsConcatEmbeddingsOptions() const
Definition schema_generated.h:2841
const tflite::FloorModOptionsT * AsFloorModOptions() const
Definition schema_generated.h:3393
tflite::NonMaxSuppressionV4OptionsT * AsNonMaxSuppressionV4Options()
Definition schema_generated.h:3573
const tflite::BatchToSpaceNDOptionsT * AsBatchToSpaceNDOptions() const
Definition schema_generated.h:3009
tflite::BidirectionalSequenceLSTMOptionsT * AsBidirectionalSequenceLSTMOptions()
Definition schema_generated.h:3365
tflite::Conv2DOptionsT * AsConv2DOptions()
Definition schema_generated.h:2821
const tflite::DensifyOptionsT * AsDensifyOptions() const
Definition schema_generated.h:3609
const tflite::TransposeOptionsT * AsTransposeOptions() const
Definition schema_generated.h:3025
const tflite::VarHandleOptionsT * AsVarHandleOptions() const
Definition schema_generated.h:3705
const tflite::UniqueOptionsT * AsUniqueOptions() const
Definition schema_generated.h:3457
const tflite::GreaterEqualOptionsT * AsGreaterEqualOptions() const
Definition schema_generated.h:3177
tflite::VarHandleOptionsT * AsVarHandleOptions()
Definition schema_generated.h:3701
tflite::StridedSliceOptionsT * AsStridedSliceOptions()
Definition schema_generated.h:3069
void Set(T &&val)
Definition schema_generated.h:2809
tflite::SliceOptionsT * AsSliceOptions()
Definition schema_generated.h:3197
tflite::HashtableFindOptionsT * AsHashtableFindOptions()
Definition schema_generated.h:3677
tflite::BidirectionalSequenceRNNOptionsT * AsBidirectionalSequenceRNNOptions()
Definition schema_generated.h:3373
const tflite::UnsortedSegmentSumOptionsT * AsUnsortedSegmentSumOptions() const
Definition schema_generated.h:3785
tflite::SquaredDifferenceOptionsT * AsSquaredDifferenceOptions()
Definition schema_generated.h:3421
tflite::GreaterEqualOptionsT * AsGreaterEqualOptions()
Definition schema_generated.h:3173
const tflite::UnsortedSegmentMaxOptionsT * AsUnsortedSegmentMaxOptions() const
Definition schema_generated.h:3769
const tflite::HashtableImportOptionsT * AsHashtableImportOptions() const
Definition schema_generated.h:3689
tflite::ArgMaxOptionsT * AsArgMaxOptions()
Definition schema_generated.h:3133
tflite::UnsortedSegmentProdOptionsT * AsUnsortedSegmentProdOptions()
Definition schema_generated.h:3757
tflite::FloorModOptionsT * AsFloorModOptions()
Definition schema_generated.h:3389
const tflite::SelectV2OptionsT * AsSelectV2Options() const
Definition schema_generated.h:3601
tflite::SplitOptionsT * AsSplitOptions()
Definition schema_generated.h:3093
tflite::ReverseV2OptionsT * AsReverseV2Options()
Definition schema_generated.h:3461
BuiltinOptionsUnion & operator=(BuiltinOptionsUnion &&u) FLATBUFFERS_NOEXCEPT
Definition schema_generated.h:2802
const tflite::ReverseSequenceOptionsT * AsReverseSequenceOptions() const
Definition schema_generated.h:3513
tflite::DivOptionsT * AsDivOptions()
Definition schema_generated.h:3045
tflite::CosOptionsT * AsCosOptions()
Definition schema_generated.h:3485
tflite::ReverseSequenceOptionsT * AsReverseSequenceOptions()
Definition schema_generated.h:3509
const tflite::CallOptionsT * AsCallOptions() const
Definition schema_generated.h:2945
const tflite::EqualOptionsT * AsEqualOptions() const
Definition schema_generated.h:3241
const tflite::L2NormOptionsT * AsL2NormOptions() const
Definition schema_generated.h:2913
const tflite::ReadVariableOptionsT * AsReadVariableOptions() const
Definition schema_generated.h:3713
tflite::WhileOptionsT * AsWhileOptions()
Definition schema_generated.h:3557
const tflite::TopKV2OptionsT * AsTopKV2Options() const
Definition schema_generated.h:3089
tflite::ConcatenationOptionsT * AsConcatenationOptions()
Definition schema_generated.h:2893
const tflite::SquaredDifferenceOptionsT * AsSquaredDifferenceOptions() const
Definition schema_generated.h:3425
tflite::NegOptionsT * AsNegOptions()
Definition schema_generated.h:3149
tflite::LeakyReluOptionsT * AsLeakyReluOptions()
Definition schema_generated.h:3413
const tflite::PadV2OptionsT * AsPadV2Options() const
Definition schema_generated.h:3161
tflite::OneHotOptionsT * AsOneHotOptions()
Definition schema_generated.h:3301
const tflite::TileOptionsT * AsTileOptions() const
Definition schema_generated.h:3225
tflite::HashtableImportOptionsT * AsHashtableImportOptions()
Definition schema_generated.h:3685
const tflite::ResizeBilinearOptionsT * AsResizeBilinearOptions() const
Definition schema_generated.h:2937
tflite::AddNOptionsT * AsAddNOptions()
Definition schema_generated.h:3469
const tflite::IfOptionsT * AsIfOptions() const
Definition schema_generated.h:3553
tflite::EqualOptionsT * AsEqualOptions()
Definition schema_generated.h:3237
tflite::LSTMOptionsT * AsLSTMOptions()
Definition schema_generated.h:2925
const tflite::LogicalOrOptionsT * AsLogicalOrOptions() const
Definition schema_generated.h:3297
tflite::SelectV2OptionsT * AsSelectV2Options()
Definition schema_generated.h:3597
const tflite::BucketizeOptionsT * AsBucketizeOptions() const
Definition schema_generated.h:3737
const tflite::LessOptionsT * AsLessOptions() const
Definition schema_generated.h:3145
tflite::CallOnceOptionsT * AsCallOnceOptions()
Definition schema_generated.h:3637
const tflite::FullyConnectedOptionsT * AsFullyConnectedOptions() const
Definition schema_generated.h:2881
tflite::ReducerOptionsT * AsReducerOptions()
Definition schema_generated.h:3029
tflite::HashtableSizeOptionsT * AsHashtableSizeOptions()
Definition schema_generated.h:3693
const tflite::SkipGramOptionsT * AsSkipGramOptions() const
Definition schema_generated.h:2961
const tflite::HardSwishOptionsT * AsHardSwishOptions() const
Definition schema_generated.h:3545
const tflite::RNNOptionsT * AsRNNOptions() const
Definition schema_generated.h:2873
tflite::ScatterNdOptionsT * AsScatterNdOptions()
Definition schema_generated.h:3589
tflite::LessEqualOptionsT * AsLessEqualOptions()
Definition schema_generated.h:3181
tflite::ExpOptionsT * AsExpOptions()
Definition schema_generated.h:3077
tflite::WhereOptionsT * AsWhereOptions()
Definition schema_generated.h:3493
tflite::CastOptionsT * AsCastOptions()
Definition schema_generated.h:3109
tflite::Pool2DOptionsT * AsPool2DOptions()
Definition schema_generated.h:2853
tflite::IfOptionsT * AsIfOptions()
Definition schema_generated.h:3549
const tflite::PackOptionsT * AsPackOptions() const
Definition schema_generated.h:3289
const tflite::CumsumOptionsT * AsCumsumOptions() const
Definition schema_generated.h:3633
tflite::AddOptionsT * AsAddOptions()
Definition schema_generated.h:2901
void * value
Definition schema_generated.h:2793
tflite::TransposeConvOptionsT * AsTransposeConvOptions()
Definition schema_generated.h:3205
tflite::SegmentSumOptionsT * AsSegmentSumOptions()
Definition schema_generated.h:3613
tflite::FloorDivOptionsT * AsFloorDivOptions()
Definition schema_generated.h:3333
tflite::ATan2OptionsT * AsATan2Options()
Definition schema_generated.h:3789
tflite::Rfft2dOptionsT * AsRfft2dOptions()
Definition schema_generated.h:3653
const tflite::ReducerOptionsT * AsReducerOptions() const
Definition schema_generated.h:3033
tflite::TransposeOptionsT * AsTransposeOptions()
Definition schema_generated.h:3021
const tflite::LocalResponseNormalizationOptionsT * AsLocalResponseNormalizationOptions() const
Definition schema_generated.h:2921
tflite::ResizeNearestNeighborOptionsT * AsResizeNearestNeighborOptions()
Definition schema_generated.h:3405
tflite::RandomOptionsT * AsRandomOptions()
Definition schema_generated.h:3725
const tflite::DivOptionsT * AsDivOptions() const
Definition schema_generated.h:3049
const tflite::ExpandDimsOptionsT * AsExpandDimsOptions() const
Definition schema_generated.h:3233
const tflite::BidirectionalSequenceLSTMOptionsT * AsBidirectionalSequenceLSTMOptions() const
Definition schema_generated.h:3369
tflite::SqueezeOptionsT * AsSqueezeOptions()
Definition schema_generated.h:3053
const tflite::LogicalNotOptionsT * AsLogicalNotOptions() const
Definition schema_generated.h:3321
const tflite::SpaceToDepthOptionsT * AsSpaceToDepthOptions() const
Definition schema_generated.h:2969
const tflite::SqueezeOptionsT * AsSqueezeOptions() const
Definition schema_generated.h:3057
tflite::NotEqualOptionsT * AsNotEqualOptions()
Definition schema_generated.h:3245
tflite::SignOptionsT * AsSignOptions()
Definition schema_generated.h:3797
void Reset()
Definition schema_generated.h:19482
const tflite::GatherNdOptionsT * AsGatherNdOptions() const
Definition schema_generated.h:3481
const tflite::NegOptionsT * AsNegOptions() const
Definition schema_generated.h:3153
tflite::MaximumMinimumOptionsT * AsMaximumMinimumOptions()
Definition schema_generated.h:3125
const tflite::AssignVariableOptionsT * AsAssignVariableOptions() const
Definition schema_generated.h:3721
BuiltinOptionsUnion & operator=(const BuiltinOptionsUnion &u)
Definition schema_generated.h:2800
tflite::SkipGramOptionsT * AsSkipGramOptions()
Definition schema_generated.h:2957
const tflite::PowOptionsT * AsPowOptions() const
Definition schema_generated.h:3265
tflite::FakeQuantOptionsT * AsFakeQuantOptions()
Definition schema_generated.h:3277
const tflite::LogicalAndOptionsT * AsLogicalAndOptions() const
Definition schema_generated.h:3313
const tflite::GeluOptionsT * AsGeluOptions() const
Definition schema_generated.h:3745
tflite::QuantizeOptionsT * AsQuantizeOptions()
Definition schema_generated.h:3525
tflite::RankOptionsT * AsRankOptions()
Definition schema_generated.h:3501
const tflite::FillOptionsT * AsFillOptions() const
Definition schema_generated.h:3361
const tflite::CastOptionsT * AsCastOptions() const
Definition schema_generated.h:3113
tflite::SquareOptionsT * AsSquareOptions()
Definition schema_generated.h:3341
const tflite::MulOptionsT * AsMulOptions() const
Definition schema_generated.h:2985
tflite::SequenceRNNOptionsT * AsSequenceRNNOptions()
Definition schema_generated.h:3061
tflite::SoftmaxOptionsT * AsSoftmaxOptions()
Definition schema_generated.h:2885
const tflite::BatchMatMulOptionsT * AsBatchMatMulOptions() const
Definition schema_generated.h:3625
tflite::DepthwiseConv2DOptionsT * AsDepthwiseConv2DOptions()
Definition schema_generated.h:2829
const tflite::BidirectionalSequenceRNNOptionsT * AsBidirectionalSequenceRNNOptions() const
Definition schema_generated.h:3377
static void * UnPack(const void *obj, BuiltinOptions type, const flatbuffers::resolver_function_t *resolver)
Definition schema_generated.h:17985
tflite::UnpackOptionsT * AsUnpackOptions()
Definition schema_generated.h:3325
tflite::BatchToSpaceNDOptionsT * AsBatchToSpaceNDOptions()
Definition schema_generated.h:3005
const tflite::SubOptionsT * AsSubOptions() const
Definition schema_generated.h:3041
Definition schema_generated.h:2549
static const BuiltinOptions enum_value
Definition schema_generated.h:2296
Definition schema_generated.h:12953
flatbuffers::Offset< CallOnceOptions > Finish()
Definition schema_generated.h:10234
flatbuffers::uoffset_t start_
Definition schema_generated.h:10226
CallOnceOptions Table
Definition schema_generated.h:10224
CallOnceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10230
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10225
void add_init_subgraph_index(int32_t init_subgraph_index)
Definition schema_generated.h:10227
Definition schema_generated.h:12929
CallOnceOptions TableType
Definition schema_generated.h:10200
Definition schema_generated.h:9517
void add_subgraph(uint32_t subgraph)
Definition schema_generated.h:6813
flatbuffers::uoffset_t start_
Definition schema_generated.h:6812
CallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6816
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6811
flatbuffers::Offset< CallOptions > Finish()
Definition schema_generated.h:6820
CallOptions Table
Definition schema_generated.h:6810
Definition schema_generated.h:9493
CallOptions TableType
Definition schema_generated.h:6786
Definition schema_generated.h:10721
flatbuffers::Offset< CastOptions > Finish()
Definition schema_generated.h:8016
CastOptions Table
Definition schema_generated.h:8003
CastOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8012
void add_in_data_type(tflite::TensorType in_data_type)
Definition schema_generated.h:8006
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8004
void add_out_data_type(tflite::TensorType out_data_type)
Definition schema_generated.h:8009
flatbuffers::uoffset_t start_
Definition schema_generated.h:8005
Definition schema_generated.h:10691
CastOptions TableType
Definition schema_generated.h:7973
Definition schema_generated.h:8194
ConcatEmbeddingsOptions Table
Definition schema_generated.h:5498
ConcatEmbeddingsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:5510
void add_embedding_dim_per_channel(flatbuffers::Offset< flatbuffers::Vector< int32_t > > embedding_dim_per_channel)
Definition schema_generated.h:5507
void add_num_columns_per_channel(flatbuffers::Offset< flatbuffers::Vector< int32_t > > num_columns_per_channel)
Definition schema_generated.h:5504
flatbuffers::uoffset_t start_
Definition schema_generated.h:5500
flatbuffers::Offset< ConcatEmbeddingsOptions > Finish()
Definition schema_generated.h:5514
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:5499
void add_num_channels(int32_t num_channels)
Definition schema_generated.h:5501
Definition schema_generated.h:8156
ConcatEmbeddingsOptions TableType
Definition schema_generated.h:5460
Definition schema_generated.h:8772
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6066
void add_axis(int32_t axis)
Definition schema_generated.h:6068
flatbuffers::Offset< ConcatenationOptions > Finish()
Definition schema_generated.h:6078
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:6071
ConcatenationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6074
ConcatenationOptions Table
Definition schema_generated.h:6065
flatbuffers::uoffset_t start_
Definition schema_generated.h:6067
Definition schema_generated.h:8742
ConcatenationOptions TableType
Definition schema_generated.h:6035
Definition schema_generated.h:7744
flatbuffers::Offset< Conv2DOptions > Finish()
Definition schema_generated.h:5078
void add_dilation_w_factor(int32_t dilation_w_factor)
Definition schema_generated.h:5068
void add_stride_w(int32_t stride_w)
Definition schema_generated.h:5059
void add_padding(tflite::Padding padding)
Definition schema_generated.h:5056
Conv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:5074
flatbuffers::uoffset_t start_
Definition schema_generated.h:5055
void add_dilation_h_factor(int32_t dilation_h_factor)
Definition schema_generated.h:5071
Conv2DOptions Table
Definition schema_generated.h:5053
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:5065
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:5054
void add_stride_h(int32_t stride_h)
Definition schema_generated.h:5062
Definition schema_generated.h:7684
Conv2DOptions TableType
Definition schema_generated.h:4999
Definition schema_generated.h:7868
void add_stride_w(int32_t stride_w)
Definition schema_generated.h:5181
flatbuffers::uoffset_t start_
Definition schema_generated.h:5174
void add_dilation_d_factor(int32_t dilation_d_factor)
Definition schema_generated.h:5190
void add_stride_d(int32_t stride_d)
Definition schema_generated.h:5178
Conv3DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:5199
Conv3DOptions Table
Definition schema_generated.h:5172
void add_padding(tflite::Padding padding)
Definition schema_generated.h:5175
void add_stride_h(int32_t stride_h)
Definition schema_generated.h:5184
void add_dilation_h_factor(int32_t dilation_h_factor)
Definition schema_generated.h:5196
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:5187
flatbuffers::Offset< Conv3DOptions > Finish()
Definition schema_generated.h:5203
void add_dilation_w_factor(int32_t dilation_w_factor)
Definition schema_generated.h:5193
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:5173
Definition schema_generated.h:7802
Conv3DOptions TableType
Definition schema_generated.h:5106
Definition schema_generated.h:10304
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7598
CosOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7600
flatbuffers::uoffset_t start_
Definition schema_generated.h:7599
flatbuffers::Offset< CosOptions > Finish()
Definition schema_generated.h:7604
CosOptions Table
Definition schema_generated.h:7597
Definition schema_generated.h:10288
CosOptions TableType
Definition schema_generated.h:7581
Definition schema_generated.h:13382
flatbuffers::Offset< CumsumOptions > Finish()
Definition schema_generated.h:10666
CumsumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10662
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10654
flatbuffers::uoffset_t start_
Definition schema_generated.h:10655
void add_reverse(bool reverse)
Definition schema_generated.h:10659
CumsumOptions Table
Definition schema_generated.h:10653
void add_exclusive(bool exclusive)
Definition schema_generated.h:10656
Definition schema_generated.h:13352
CumsumOptions TableType
Definition schema_generated.h:10623
Definition schema_generated.h:5022
void add_custom(flatbuffers::Offset< flatbuffers::Vector< uint8_t > > custom)
Definition schema_generated.h:4094
flatbuffers::uoffset_t start_
Definition schema_generated.h:4093
CustomQuantization Table
Definition schema_generated.h:4091
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:4092
flatbuffers::Offset< CustomQuantization > Finish()
Definition schema_generated.h:4101
CustomQuantizationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:4097
Definition schema_generated.h:4997
CustomQuantization TableType
Definition schema_generated.h:4066
std::vector< uint8_t > custom
Definition schema_generated.h:4067
Definition schema_generated.h:13216
DensifyOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10490
DensifyOptions Table
Definition schema_generated.h:10487
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10488
flatbuffers::uoffset_t start_
Definition schema_generated.h:10489
flatbuffers::Offset< DensifyOptions > Finish()
Definition schema_generated.h:10494
Definition schema_generated.h:13200
DensifyOptions TableType
Definition schema_generated.h:10471
Definition schema_generated.h:9913
flatbuffers::Offset< DepthToSpaceOptions > Finish()
Definition schema_generated.h:7216
DepthToSpaceOptions Table
Definition schema_generated.h:7206
DepthToSpaceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7212
flatbuffers::uoffset_t start_
Definition schema_generated.h:7208
void add_block_size(int32_t block_size)
Definition schema_generated.h:7209
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7207
Definition schema_generated.h:9889
DepthToSpaceOptions TableType
Definition schema_generated.h:7182
Definition schema_generated.h:8098
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:5403
void add_dilation_h_factor(int32_t dilation_h_factor)
Definition schema_generated.h:5423
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:5417
flatbuffers::Offset< DepthwiseConv2DOptions > Finish()
Definition schema_generated.h:5430
void add_padding(tflite::Padding padding)
Definition schema_generated.h:5405
void add_stride_h(int32_t stride_h)
Definition schema_generated.h:5411
DepthwiseConv2DOptions Table
Definition schema_generated.h:5402
void add_dilation_w_factor(int32_t dilation_w_factor)
Definition schema_generated.h:5420
void add_depth_multiplier(int32_t depth_multiplier)
Definition schema_generated.h:5414
flatbuffers::uoffset_t start_
Definition schema_generated.h:5404
void add_stride_w(int32_t stride_w)
Definition schema_generated.h:5408
DepthwiseConv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:5426
Definition schema_generated.h:8038
DepthwiseConv2DOptions TableType
Definition schema_generated.h:5342
Definition schema_generated.h:10770
flatbuffers::Offset< DequantizeOptions > Finish()
Definition schema_generated.h:8059
flatbuffers::uoffset_t start_
Definition schema_generated.h:8054
DequantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8055
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8053
DequantizeOptions Table
Definition schema_generated.h:8052
Definition schema_generated.h:10754
DequantizeOptions TableType
Definition schema_generated.h:8036
Definition schema_generated.h:5500
DimensionMetadata Table
Definition schema_generated.h:4569
DimensionMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:4590
flatbuffers::uoffset_t start_
Definition schema_generated.h:4571
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:4570
void add_array_segments_type(tflite::SparseIndexVector array_segments_type)
Definition schema_generated.h:4578
void add_dense_size(int32_t dense_size)
Definition schema_generated.h:4575
void add_array_segments(flatbuffers::Offset< void > array_segments)
Definition schema_generated.h:4581
void add_array_indices(flatbuffers::Offset< void > array_indices)
Definition schema_generated.h:4587
void add_array_indices_type(tflite::SparseIndexVector array_indices_type)
Definition schema_generated.h:4584
void add_format(tflite::DimensionType format)
Definition schema_generated.h:4572
flatbuffers::Offset< DimensionMetadata > Finish()
Definition schema_generated.h:4594
Definition schema_generated.h:5402
tflite::SparseIndexVectorUnion array_segments
Definition schema_generated.h:4474
tflite::SparseIndexVectorUnion array_indices
Definition schema_generated.h:4475
tflite::DimensionType format
Definition schema_generated.h:4472
int32_t dense_size
Definition schema_generated.h:4473
DimensionMetadata TableType
Definition schema_generated.h:4471
Definition schema_generated.h:10028
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:7324
DivOptions Table
Definition schema_generated.h:7321
flatbuffers::uoffset_t start_
Definition schema_generated.h:7323
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7322
DivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7327
flatbuffers::Offset< DivOptions > Finish()
Definition schema_generated.h:7331
Definition schema_generated.h:10004
DivOptions TableType
Definition schema_generated.h:7297
Definition schema_generated.h:14032
DynamicUpdateSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11306
flatbuffers::Offset< DynamicUpdateSliceOptions > Finish()
Definition schema_generated.h:11310
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:11304
DynamicUpdateSliceOptions Table
Definition schema_generated.h:11303
flatbuffers::uoffset_t start_
Definition schema_generated.h:11305
Definition schema_generated.h:14016
DynamicUpdateSliceOptions TableType
Definition schema_generated.h:11287
Definition schema_generated.h:10119
EmbeddingLookupSparseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7418
void add_combiner(tflite::CombinerType combiner)
Definition schema_generated.h:7415
flatbuffers::Offset< EmbeddingLookupSparseOptions > Finish()
Definition schema_generated.h:7422
flatbuffers::uoffset_t start_
Definition schema_generated.h:7414
EmbeddingLookupSparseOptions Table
Definition schema_generated.h:7412
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7413
Definition schema_generated.h:10095
EmbeddingLookupSparseOptions TableType
Definition schema_generated.h:7388
Definition schema_generated.h:11451
EqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8725
flatbuffers::uoffset_t start_
Definition schema_generated.h:8724
flatbuffers::Offset< EqualOptions > Finish()
Definition schema_generated.h:8729
EqualOptions Table
Definition schema_generated.h:8722
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8723
Definition schema_generated.h:11435
EqualOptions TableType
Definition schema_generated.h:8706
Definition schema_generated.h:10265
ExpOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7561
flatbuffers::Offset< ExpOptions > Finish()
Definition schema_generated.h:7565
flatbuffers::uoffset_t start_
Definition schema_generated.h:7560
ExpOptions Table
Definition schema_generated.h:7558
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7559
Definition schema_generated.h:10249
ExpOptions TableType
Definition schema_generated.h:7542
Definition schema_generated.h:11360
ExpandDimsOptions Table
Definition schema_generated.h:8631
ExpandDimsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8634
flatbuffers::Offset< ExpandDimsOptions > Finish()
Definition schema_generated.h:8638
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8632
flatbuffers::uoffset_t start_
Definition schema_generated.h:8633
Definition schema_generated.h:11344
ExpandDimsOptions TableType
Definition schema_generated.h:8615
Definition schema_generated.h:16342
Conv3DOptionsT NativeTableType
Definition schema_generated.h:5118
RNNOptionsBuilder Builder
Definition schema_generated.h:5683
static flatbuffers::Offset< SplitVOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::SegmentSumOptions * builtin_options_as_SegmentSumOptions() const
Definition schema_generated.h:11999
MatrixDiagOptionsBuilder Builder
Definition schema_generated.h:10025
GreaterEqualOptionsT NativeTableType
Definition schema_generated.h:8300
const tflite::ReducerOptions * builtin_options_as_ReducerOptions() const
Definition schema_generated.h:11780
BidirectionalSequenceLSTMOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(LSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
EmbeddingLookupSparseOptionsT NativeTableType
Definition schema_generated.h:7393
MaximumMinimumOptionsT NativeTableType
Definition schema_generated.h:8079
BatchToSpaceNDOptionsT NativeTableType
Definition schema_generated.h:7021
SparseToDenseOptionsT NativeTableType
Definition schema_generated.h:8659
AddNOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
CustomQuantizationBuilder Builder
Definition schema_generated.h:4072
const tflite::UnpackOptions * builtin_options_as_UnpackOptions() const
Definition schema_generated.h:11891
BatchToSpaceNDOptionsBuilder Builder
Definition schema_generated.h:7022
uint32_t subgraph_index() const
Definition schema_generated.h:13067
DivOptionsBuilder Builder
Definition schema_generated.h:7303
const tflite::MatrixDiagOptions * builtin_options_as_MatrixDiagOptions() const
Definition schema_generated.h:11963
const tflite::BidirectionalSequenceRNNOptions * builtin_options_as_BidirectionalSequenceRNNOptions() const
Definition schema_generated.h:11909
AbsOptionsBuilder Builder
Definition schema_generated.h:9158
const flatbuffers::Vector< int32_t > * shape() const
Definition schema_generated.h:4733
ATan2OptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
SqueezeOptionsT NativeTableType
Definition schema_generated.h:7677
BucketizeOptionsBuilder Builder
Definition schema_generated.h:11179
const tflite::ShapeOptions * builtin_options_as_ShapeOptions() const
Definition schema_generated.h:11864
LessOptionsT NativeTableType
Definition schema_generated.h:8339
SquareOptionsBuilder Builder
Definition schema_generated.h:9416
const tflite::SpaceToBatchNDOptions * builtin_options_as_SpaceToBatchNDOptions() const
Definition schema_generated.h:11774
WhileOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
int32_t cond_subgraph_index() const
Definition schema_generated.h:10264
const flatbuffers::Vector< int32_t > * outputs() const
Definition schema_generated.h:11692
static flatbuffers::Offset< Conv2DOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(GatherOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< GreaterEqualOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::ArgMinOptions * builtin_options_as_ArgMinOptions() const
Definition schema_generated.h:11870
SoftmaxOptionsT NativeTableType
Definition schema_generated.h:5988
const tflite::HashtableImportOptions * builtin_options_as_HashtableImportOptions() const
Definition schema_generated.h:12026
const flatbuffers::Vector< flatbuffers::Offset< tflite::Operator > > * operators() const
Definition schema_generated.h:12728
static flatbuffers::Offset< LSTMOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
NotEqualOptionsT NativeTableType
Definition schema_generated.h:8749
const tflite::SignOptions * builtin_options_as_SignOptions() const
Definition schema_generated.h:12068
const T * array_indices_as() const
DynamicUpdateSliceOptionsBuilder Builder
Definition schema_generated.h:11292
const flatbuffers::Vector< int32_t > * shape_signature() const
Definition schema_generated.h:4860
void UnPackTo(SparseToDenseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::TileOptions * builtin_options_as_TileOptions() const
Definition schema_generated.h:11852
static flatbuffers::Offset< HashtableSizeOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableSizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::ConcatenationOptions * builtin_options_as_ConcatenationOptions() const
Definition schema_generated.h:11729
const tflite::GatherNdOptions * builtin_options_as_GatherNdOptions() const
Definition schema_generated.h:11948
static flatbuffers::Offset< BidirectionalSequenceRNNOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(QuantizationParametersT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
bool diagonal_recurrent_tensors() const
Definition schema_generated.h:6481
static flatbuffers::Offset< QuantizeOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
FillOptionsT NativeTableType
Definition schema_generated.h:9493
UnsortedSegmentMaxOptionsT NativeTableType
Definition schema_generated.h:11369
HardSwishOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
TransposeConvOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
GatherOptionsT NativeTableType
Definition schema_generated.h:7446
UnsortedSegmentProdOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::OneHotOptions * builtin_options_as_OneHotOptions() const
Definition schema_generated.h:11882
void UnPackTo(GatherNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
RandomOptionsT NativeTableType
Definition schema_generated.h:11116
TileOptionsT NativeTableType
Definition schema_generated.h:8118
HashtableOptionsBuilder Builder
Definition schema_generated.h:10772
int32_t else_subgraph_index() const
Definition schema_generated.h:10152
LSTMOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::TopKV2Options * builtin_options_as_TopKV2Options() const
Definition schema_generated.h:11801
void UnPackTo(SpaceToBatchNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(SubGraphT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(OperatorT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< DimensionMetadata > Pack(flatbuffers::FlatBufferBuilder &_fbb, const DimensionMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::RandomOptions * builtin_options_as_RandomOptions() const
Definition schema_generated.h:12041
const tflite::TransposeConvOptions * builtin_options_as_TransposeConvOptions() const
Definition schema_generated.h:11846
ExpOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
tflite::TensorType out_type() const
Definition schema_generated.h:8794
void UnPackTo(BatchToSpaceNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
tflite::DimensionType format() const
Definition schema_generated.h:4489
void UnPackTo(SubOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
int32_t batch_dims() const
Definition schema_generated.h:7455
static flatbuffers::Offset< FloorModOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< HashtableOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
SparseToDenseOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const flatbuffers::Vector< uint8_t > * custom_options() const
Definition schema_generated.h:12071
bool adj_x() const
Definition schema_generated.h:10563
const tflite::Conv2DOptions * builtin_options_as_Conv2DOptions() const
Definition schema_generated.h:11702
void UnPackTo(NonMaxSuppressionV5OptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(DepthwiseConv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< FillOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
Uint8VectorBuilder Builder
Definition schema_generated.h:4414
OperatorCodeBuilder Builder
Definition schema_generated.h:11569
void UnPackTo(WhereOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
ZerosLikeOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< LessOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
OperatorCodeT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
UnsortedSegmentProdOptionsBuilder Builder
Definition schema_generated.h:11331
PadOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< BatchToSpaceNDOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
VarHandleOptionsT NativeTableType
Definition schema_generated.h:10961
int32_t num() const
Definition schema_generated.h:9321
static flatbuffers::Offset< SkipGramOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
FillOptionsBuilder Builder
Definition schema_generated.h:9494
TransposeConvOptionsT NativeTableType
Definition schema_generated.h:8538
static flatbuffers::Offset< FloorDivOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< TransposeOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
LogicalOrOptionsBuilder Builder
Definition schema_generated.h:9067
static flatbuffers::Offset< NotEqualOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< CustomQuantization > Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
FloorModOptionsT NativeTableType
Definition schema_generated.h:9532
static flatbuffers::Offset< MatrixSetDiagOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixSetDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
uint32_t version() const
Definition schema_generated.h:13177
void UnPackTo(SelectOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(GeluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
ReducerOptionsBuilder Builder
Definition schema_generated.h:7626
const tflite::DepthToSpaceOptions * builtin_options_as_DepthToSpaceOptions() const
Definition schema_generated.h:11981
const tflite::SubOptions * builtin_options_as_SubOptions() const
Definition schema_generated.h:11783
HashtableSizeOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(SquaredDifferenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
WhereOptionsBuilder Builder
Definition schema_generated.h:9923
SelectOptionsT NativeTableType
Definition schema_generated.h:8456
void UnPackTo(AddOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
ArgMinOptionsT NativeTableType
Definition schema_generated.h:8210
static flatbuffers::Offset< SpaceToBatchNDOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
ReadVariableOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::FloorModOptions * builtin_options_as_FloorModOptions() const
Definition schema_generated.h:11915
AddOptionsT NativeTableType
Definition schema_generated.h:6104
WhereOptionsT NativeTableType
Definition schema_generated.h:9922
SegmentSumOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
NonMaxSuppressionV4OptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< OperatorCode > Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(NotEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::FakeQuantOptions * builtin_options_as_FakeQuantOptions() const
Definition schema_generated.h:11873
static flatbuffers::Offset< UniqueOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(UnsortedSegmentSumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
SquareOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< LocalResponseNormalizationOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(FakeQuantOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
TileOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
EmbeddingLookupSparseOptionsBuilder Builder
Definition schema_generated.h:7394
UnpackOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< SpaceToDepthOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
SoftmaxOptionsBuilder Builder
Definition schema_generated.h:5989
const tflite::Pool2DOptions * builtin_options_as_Pool2DOptions() const
Definition schema_generated.h:11714
static flatbuffers::Offset< LogicalOrOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const flatbuffers::Vector< flatbuffers::Offset< tflite::SignatureDef > > * signature_defs() const
Definition schema_generated.h:13198
SkipGramOptionsBuilder Builder
Definition schema_generated.h:7064
void UnPackTo(PadV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const void * builtin_options() const
Definition schema_generated.h:11698
const tflite::UniqueOptions * builtin_options_as_UniqueOptions() const
Definition schema_generated.h:11939
bool merge_outputs() const
Definition schema_generated.h:5835
UnsortedSegmentProdOptionsT NativeTableType
Definition schema_generated.h:11330
void UnPackTo(SparsityParametersT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
HashtableFindOptionsT NativeTableType
Definition schema_generated.h:10842
void UnPackTo(HashtableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
LessEqualOptionsT NativeTableType
Definition schema_generated.h:8378
SelectV2OptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(ReshapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
SelectOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< LogSoftmaxOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(L2NormOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(UnpackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
MetadataT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
int32_t end_mask() const
Definition schema_generated.h:7859
CumsumOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::LSTMOptions * builtin_options_as_LSTMOptions() const
Definition schema_generated.h:11741
EmbeddingLookupSparseOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
LessEqualOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::LSHProjectionOptions * builtin_options_as_LSHProjectionOptions() const
Definition schema_generated.h:11711
DensifyOptionsT NativeTableType
Definition schema_generated.h:10475
void UnPackTo(PadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
GreaterEqualOptionsBuilder Builder
Definition schema_generated.h:8301
const tflite::SplitOptions * builtin_options_as_SplitOptions() const
Definition schema_generated.h:11804
const tflite::Uint16Vector * array_indices_as_Uint16Vector() const
Definition schema_generated.h:4521
const tflite::DequantizeOptions * builtin_options_as_DequantizeOptions() const
Definition schema_generated.h:11813
SequenceRNNOptionsT NativeTableType
Definition schema_generated.h:5746
const flatbuffers::Vector< int64_t > * zero_point() const
Definition schema_generated.h:4159
void UnPackTo(Rfft2dOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< ResizeNearestNeighborOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(HardSwishOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::ZerosLikeOptions * builtin_options_as_ZerosLikeOptions() const
Definition schema_generated.h:11900
Conv3DOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
RankOptionsBuilder Builder
Definition schema_generated.h:8841
UnsortedSegmentMaxOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
LogicalAndOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
CallOptionsT NativeTableType
Definition schema_generated.h:6791
const flatbuffers::Vector< float > * min() const
Definition schema_generated.h:4150
const flatbuffers::Vector< int32_t > * metadata_buffer() const
Definition schema_generated.h:13192
static flatbuffers::Offset< ReadVariableOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReadVariableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< DynamicUpdateSliceOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const DynamicUpdateSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< SVDFOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(ConcatenationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
SignatureDefT NativeTableType
Definition schema_generated.h:13050
EqualOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
ExpandDimsOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::AddNOptions * builtin_options_as_AddNOptions() const
Definition schema_generated.h:11945
TensorMapT NativeTableType
Definition schema_generated.h:12969
const tflite::HashtableOptions * builtin_options_as_HashtableOptions() const
Definition schema_generated.h:12020
LeakyReluOptionsBuilder Builder
Definition schema_generated.h:9612
const tflite::Uint16Vector * array_segments_as_Uint16Vector() const
Definition schema_generated.h:4505
HashtableImportOptionsT NativeTableType
Definition schema_generated.h:10881
const T * builtin_options_as() const
const tflite::UnsortedSegmentSumOptions * builtin_options_as_UnsortedSegmentSumOptions() const
Definition schema_generated.h:12062
const flatbuffers::String * signature_key() const
Definition schema_generated.h:13064
QuantizeOptionsBuilder Builder
Definition schema_generated.h:10064
MulOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
TransposeOptionsT NativeTableType
Definition schema_generated.h:7507
GreaterOptionsT NativeTableType
Definition schema_generated.h:8261
const tflite::TransposeOptions * builtin_options_as_TransposeOptions() const
Definition schema_generated.h:11777
ReducerOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
QuantizationParametersT NativeTableType
Definition schema_generated.h:4139
GatherNdOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
Conv2DOptionsBuilder Builder
Definition schema_generated.h:5010
static flatbuffers::Offset< ScatterNdOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScatterNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const flatbuffers::Vector< int32_t > * new_shape() const
Definition schema_generated.h:6926
RNNOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(CumsumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(SelectV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(TensorT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(SplitOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
bool approximate() const
Definition schema_generated.h:11245
static flatbuffers::Offset< SubOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const flatbuffers::Vector< flatbuffers::Offset< tflite::TensorMap > > * inputs() const
Definition schema_generated.h:13058
BatchMatMulOptionsBuilder Builder
Definition schema_generated.h:10557
GatherOptionsBuilder Builder
Definition schema_generated.h:7447
static flatbuffers::Offset< SoftmaxOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< RandomOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const RandomOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(FloorModOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
bool asymmetric_quantize_inputs() const
Definition schema_generated.h:5622
AssignVariableOptionsBuilder Builder
Definition schema_generated.h:11076
void UnPackTo(SegmentSumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
UniqueOptionsT NativeTableType
Definition schema_generated.h:9754
SqueezeOptionsBuilder Builder
Definition schema_generated.h:7678
const tflite::ResizeBilinearOptions * builtin_options_as_ResizeBilinearOptions() const
Definition schema_generated.h:11744
bool half_pixel_centers() const
Definition schema_generated.h:6675
void UnPackTo(BatchMatMulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
SignOptionsBuilder Builder
Definition schema_generated.h:11526
Uint16VectorT NativeTableType
Definition schema_generated.h:4350
DivOptionsT NativeTableType
Definition schema_generated.h:7302
ExpandDimsOptionsBuilder Builder
Definition schema_generated.h:8620
tflite::TensorType value_dtype() const
Definition schema_generated.h:10784
int32_t new_axis_mask() const
Definition schema_generated.h:7865
void UnPackTo(DivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
LSHProjectionOptionsBuilder Builder
Definition schema_generated.h:5556
const flatbuffers::String * name() const
Definition schema_generated.h:4848
SliceOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< Rfft2dOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const Rfft2dOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
ConcatenationOptionsBuilder Builder
Definition schema_generated.h:6042
static flatbuffers::Offset< VariantSubType > Pack(flatbuffers::FlatBufferBuilder &_fbb, const VariantSubTypeT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
int32_t filter_height() const
Definition schema_generated.h:5267
int32_t filter_width() const
Definition schema_generated.h:5264
int32_t stride_w() const
Definition schema_generated.h:5022
static flatbuffers::Offset< AddNOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
SVDFOptionsT NativeTableType
Definition schema_generated.h:5609
LSHProjectionOptionsT NativeTableType
Definition schema_generated.h:5555
int64_t seed2() const
Definition schema_generated.h:11125
void UnPackTo(MatrixDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
HashtableSizeOptionsBuilder Builder
Definition schema_generated.h:10921
ConcatEmbeddingsOptionsBuilder Builder
Definition schema_generated.h:5468
void UnPackTo(ReverseSequenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
ReverseV2OptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::UnsortedSegmentMaxOptions * builtin_options_as_UnsortedSegmentMaxOptions() const
Definition schema_generated.h:12056
int32_t rank() const
Definition schema_generated.h:5616
void UnPackTo(GreaterOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
ArgMinOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(BroadcastToOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::ExpOptions * builtin_options_as_ExpOptions() const
Definition schema_generated.h:11798
const tflite::SequenceRNNOptions * builtin_options_as_SequenceRNNOptions() const
Definition schema_generated.h:11792
GatherOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< ConcatenationOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< DepthwiseConv2DOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::ExpandDimsOptions * builtin_options_as_ExpandDimsOptions() const
Definition schema_generated.h:11855
SplitOptionsBuilder Builder
Definition schema_generated.h:7740
const tflite::SelectV2Options * builtin_options_as_SelectV2Options() const
Definition schema_generated.h:11993
ReducerOptionsT NativeTableType
Definition schema_generated.h:7625
UnsortedSegmentMinOptionsBuilder Builder
Definition schema_generated.h:11487
static flatbuffers::Offset< LessEqualOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(OneHotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
Uint8VectorT NativeTableType
Definition schema_generated.h:4413
SquaredDifferenceOptionsBuilder Builder
Definition schema_generated.h:9663
float alpha() const
Definition schema_generated.h:6287
static flatbuffers::Offset< Model > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
BatchMatMulOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
SubGraphBuilder Builder
Definition schema_generated.h:12711
UniqueOptionsBuilder Builder
Definition schema_generated.h:9755
void UnPackTo(LessOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
LogicalOrOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
GreaterOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
FakeQuantOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::CallOnceOptions * builtin_options_as_CallOnceOptions() const
Definition schema_generated.h:12008
SignatureDefBuilder Builder
Definition schema_generated.h:13051
AbsOptionsT NativeTableType
Definition schema_generated.h:9157
void UnPackTo(FloorDivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
ScatterNdOptionsBuilder Builder
Definition schema_generated.h:10398
void UnPackTo(HashtableImportOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::LocalResponseNormalizationOptions * builtin_options_as_LocalResponseNormalizationOptions() const
Definition schema_generated.h:11738
static flatbuffers::Offset< Operator > Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
GeluOptionsT NativeTableType
Definition schema_generated.h:11240
float max() const
Definition schema_generated.h:8933
const tflite::Conv3DOptions * builtin_options_as_Conv3DOptions() const
Definition schema_generated.h:12017
void UnPackTo(WhileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
float cell_clip() const
Definition schema_generated.h:6371
static flatbuffers::Offset< BroadcastToOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const BroadcastToOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(ReverseV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::RangeOptions * builtin_options_as_RangeOptions() const
Definition schema_generated.h:11918
uint32_t buffer() const
Definition schema_generated.h:4845
FloorModOptionsBuilder Builder
Definition schema_generated.h:9533
BatchMatMulOptionsT NativeTableType
Definition schema_generated.h:10556
UnpackOptionsT NativeTableType
Definition schema_generated.h:9315
void UnPackTo(LSHProjectionOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(UnsortedSegmentProdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::BroadcastToOptions * builtin_options_as_BroadcastToOptions() const
Definition schema_generated.h:12011
void UnPackTo(SplitVOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
NonMaxSuppressionV4OptionsBuilder Builder
Definition schema_generated.h:10320
RangeOptionsT NativeTableType
Definition schema_generated.h:9571
LeakyReluOptionsT NativeTableType
Definition schema_generated.h:9611
const tflite::SquareOptions * builtin_options_as_SquareOptions() const
Definition schema_generated.h:11897
void UnPackTo(VariantSubTypeT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(Int32VectorT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
TensorT NativeTableType
Definition schema_generated.h:4825
const T * array_segments_as() const
BidirectionalSequenceRNNOptionsT NativeTableType
Definition schema_generated.h:5821
static flatbuffers::Offset< GatherOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
VariantSubTypeT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(BucketizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::MaximumMinimumOptions * builtin_options_as_MaximumMinimumOptions() const
Definition schema_generated.h:11816
static flatbuffers::Offset< Uint8Vector > Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint8VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
ArgMaxOptionsBuilder Builder
Definition schema_generated.h:8159
tflite::CombinerType combiner() const
Definition schema_generated.h:7398
static flatbuffers::Offset< TensorMap > Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMapT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< BatchMatMulOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
StridedSliceOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
PadOptionsT NativeTableType
Definition schema_generated.h:6842
const flatbuffers::Vector< int32_t > * intermediates() const
Definition schema_generated.h:12080
SplitVOptionsT NativeTableType
Definition schema_generated.h:7791
PadV2OptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const flatbuffers::Vector< int32_t > * squeeze_dims() const
Definition schema_generated.h:7682
VarHandleOptionsBuilder Builder
Definition schema_generated.h:10962
tflite::TensorType in_data_type() const
Definition schema_generated.h:7985
NegOptionsT NativeTableType
Definition schema_generated.h:8417
SkipGramOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< AssignVariableOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const AssignVariableOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
LessEqualOptionsBuilder Builder
Definition schema_generated.h:8379
static flatbuffers::Offset< DensifyOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const DensifyOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
LogicalNotOptionsBuilder Builder
Definition schema_generated.h:9275
void UnPackTo(SequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
FloorDivOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const flatbuffers::Vector< int32_t > * num_columns_per_channel() const
Definition schema_generated.h:5477
int32_t num_bits() const
Definition schema_generated.h:8936
int32_t stride_d() const
Definition schema_generated.h:5133
NotEqualOptionsBuilder Builder
Definition schema_generated.h:8750
static flatbuffers::Offset< Metadata > Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
PackOptionsBuilder Builder
Definition schema_generated.h:9006
void UnPackTo(CallOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
MirrorPadOptionsBuilder Builder
Definition schema_generated.h:9703
TransposeOptionsBuilder Builder
Definition schema_generated.h:7508
HardSwishOptionsBuilder Builder
Definition schema_generated.h:9197
AssignVariableOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(LocalResponseNormalizationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< PadV2Options > Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
Int32VectorT NativeTableType
Definition schema_generated.h:4288
static flatbuffers::Offset< ReverseV2Options > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< UnpackOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::GreaterEqualOptions * builtin_options_as_GreaterEqualOptions() const
Definition schema_generated.h:11834
void UnPackTo(IfOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
bool keep_dims() const
Definition schema_generated.h:7630
static flatbuffers::Offset< PowOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
DimensionMetadataT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
FakeQuantOptionsT NativeTableType
Definition schema_generated.h:8922
void UnPackTo(SoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< CosOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< LeakyReluOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
OperatorCodeT NativeTableType
Definition schema_generated.h:11568
const tflite::LogicalNotOptions * builtin_options_as_LogicalNotOptions() const
Definition schema_generated.h:11888
void UnPackTo(Pool2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
LocalResponseNormalizationOptionsBuilder Builder
Definition schema_generated.h:6274
ReverseSequenceOptionsT NativeTableType
Definition schema_generated.h:9963
HashtableFindOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< TileOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(PowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< SparseToDenseOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
SkipGramOptionsT NativeTableType
Definition schema_generated.h:7063
int8_t deprecated_builtin_code() const
Definition schema_generated.h:11576
int32_t dilation_d_factor() const
Definition schema_generated.h:5145
const tflite::ReadVariableOptions * builtin_options_as_ReadVariableOptions() const
Definition schema_generated.h:12035
const void * array_segments() const
Definition schema_generated.h:4498
FloorDivOptionsT NativeTableType
Definition schema_generated.h:9376
LSTMOptionsT NativeTableType
Definition schema_generated.h:6359
SequenceRNNOptionsBuilder Builder
Definition schema_generated.h:5747
void UnPackTo(AssignVariableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::ReverseSequenceOptions * builtin_options_as_ReverseSequenceOptions() const
Definition schema_generated.h:11960
SpaceToDepthOptionsBuilder Builder
Definition schema_generated.h:7136
const tflite::LeakyReluOptions * builtin_options_as_LeakyReluOptions() const
Definition schema_generated.h:11924
void UnPackTo(AbsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const flatbuffers::Vector< flatbuffers::Offset< tflite::Metadata > > * metadata() const
Definition schema_generated.h:13195
static flatbuffers::Offset< IfOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const IfOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const flatbuffers::Vector< int32_t > * block_map() const
Definition schema_generated.h:4643
BucketizeOptionsT NativeTableType
Definition schema_generated.h:11178
static flatbuffers::Offset< ArgMinOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
ReshapeOptionsBuilder Builder
Definition schema_generated.h:6922
AddNOptionsBuilder Builder
Definition schema_generated.h:9845
static flatbuffers::Offset< L2NormOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
int32_t max_skip_size() const
Definition schema_generated.h:7073
void UnPackTo(NegOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
UnsortedSegmentMinOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::SVDFOptions * builtin_options_as_SVDFOptions() const
Definition schema_generated.h:11717
int32_t depth_multiplier() const
Definition schema_generated.h:5373
ArgMaxOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
DepthwiseConv2DOptionsBuilder Builder
Definition schema_generated.h:5354
const void * array_indices() const
Definition schema_generated.h:4514
LogicalOrOptionsT NativeTableType
Definition schema_generated.h:9066
void UnPackTo(ConcatEmbeddingsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const flatbuffers::String * custom_code() const
Definition schema_generated.h:11579
TileOptionsBuilder Builder
Definition schema_generated.h:8119
TensorBuilder Builder
Definition schema_generated.h:4826
bool adj_y() const
Definition schema_generated.h:10566
void UnPackTo(GreaterEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
SquaredDifferenceOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::ResizeNearestNeighborOptions * builtin_options_as_ResizeNearestNeighborOptions() const
Definition schema_generated.h:11921
const tflite::UnsortedSegmentProdOptions * builtin_options_as_UnsortedSegmentProdOptions() const
Definition schema_generated.h:12053
bool keep_num_dims() const
Definition schema_generated.h:5920
const flatbuffers::Vector< flatbuffers::Offset< tflite::TensorMap > > * outputs() const
Definition schema_generated.h:13061
TopKV2OptionsBuilder Builder
Definition schema_generated.h:7354
void UnPackTo(LogicalNotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
float min() const
Definition schema_generated.h:8930
void UnPackTo(DequantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
IfOptionsT NativeTableType
Definition schema_generated.h:10143
static flatbuffers::Offset< UnsortedSegmentProdOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentProdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< SliceOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< PackOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
SqueezeOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< TopKV2Options > Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(MulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(DimensionMetadataT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
CosOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
LogicalAndOptionsT NativeTableType
Definition schema_generated.h:9235
SliceOptionsT NativeTableType
Definition schema_generated.h:8495
tflite::TensorType idx_out_type() const
Definition schema_generated.h:9759
int32_t begin_mask() const
Definition schema_generated.h:7856
void UnPackTo(MaximumMinimumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
SplitOptionsT NativeTableType
Definition schema_generated.h:7739
void UnPackTo(TileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
float proj_clip() const
Definition schema_generated.h:6374
RNNOptionsT NativeTableType
Definition schema_generated.h:5682
const flatbuffers::Vector< uint8_t > * data() const
Definition schema_generated.h:12835
DequantizeOptionsBuilder Builder
Definition schema_generated.h:8041
ArgMaxOptionsT NativeTableType
Definition schema_generated.h:8158
UniqueOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(LogSoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< ShapeOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
bool include_all_ngrams() const
Definition schema_generated.h:7076
static flatbuffers::Offset< OneHotOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< AddOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
int32_t dilation_h_factor() const
Definition schema_generated.h:5034
SplitOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< StridedSliceOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::LogicalAndOptions * builtin_options_as_LogicalAndOptions() const
Definition schema_generated.h:11885
UnsortedSegmentSumOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(RangeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< MirrorPadOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::AbsOptions * builtin_options_as_AbsOptions() const
Definition schema_generated.h:11933
static flatbuffers::Offset< SignOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
L2NormOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::CallOptions * builtin_options_as_CallOptions() const
Definition schema_generated.h:11747
bool exclusive() const
Definition schema_generated.h:10635
const tflite::SplitVOptions * builtin_options_as_SplitVOptions() const
Definition schema_generated.h:11936
const tflite::Uint8Vector * array_indices_as_Uint8Vector() const
Definition schema_generated.h:4524
const flatbuffers::Vector< flatbuffers::Offset< tflite::DimensionMetadata > > * dim_metadata() const
Definition schema_generated.h:4646
SubOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::BucketizeOptions * builtin_options_as_BucketizeOptions() const
Definition schema_generated.h:12044
const flatbuffers::Vector< flatbuffers::Offset< tflite::Buffer > > * buffers() const
Definition schema_generated.h:13189
DensifyOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(ReducerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
VariantSubTypeBuilder Builder
Definition schema_generated.h:4727
SelectV2OptionsBuilder Builder
Definition schema_generated.h:10437
tflite::TensorType output_type() const
Definition schema_generated.h:8163
ConcatenationOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
LogicalNotOptionsT NativeTableType
Definition schema_generated.h:9274
const flatbuffers::Vector< float > * scale() const
Definition schema_generated.h:4156
WhileOptionsT NativeTableType
Definition schema_generated.h:10258
CallOptionsBuilder Builder
Definition schema_generated.h:6792
SubOptionsT NativeTableType
Definition schema_generated.h:7240
EqualOptionsBuilder Builder
Definition schema_generated.h:8711
HashtableOptionsT NativeTableType
Definition schema_generated.h:10771
ModelT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
ShapeOptionsBuilder Builder
Definition schema_generated.h:8790
static flatbuffers::Offset< GeluOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const GeluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(SignOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::SquaredDifferenceOptions * builtin_options_as_SquaredDifferenceOptions() const
Definition schema_generated.h:11927
static flatbuffers::Offset< EqualOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::EqualOptions * builtin_options_as_EqualOptions() const
Definition schema_generated.h:11858
static flatbuffers::Offset< Int32Vector > Pack(flatbuffers::FlatBufferBuilder &_fbb, const Int32VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< HardSwishOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const HardSwishOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
int32_t table_id() const
Definition schema_generated.h:10778
static flatbuffers::Offset< EmbeddingLookupSparseOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
tflite::TensorType out_data_type() const
Definition schema_generated.h:7988
OperatorT NativeTableType
Definition schema_generated.h:11673
const tflite::NegOptions * builtin_options_as_NegOptions() const
Definition schema_generated.h:11825
const tflite::NotEqualOptions * builtin_options_as_NotEqualOptions() const
Definition schema_generated.h:11861
const flatbuffers::Vector< flatbuffers::Offset< tflite::OperatorCode > > * operator_codes() const
Definition schema_generated.h:13180
UnpackOptionsBuilder Builder
Definition schema_generated.h:9316
NonMaxSuppressionV4OptionsT NativeTableType
Definition schema_generated.h:10319
Pool2DOptionsBuilder Builder
Definition schema_generated.h:5246
LessOptionsBuilder Builder
Definition schema_generated.h:8340
ResizeBilinearOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(UniqueOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< ATan2Options > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ATan2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
ATan2OptionsBuilder Builder
Definition schema_generated.h:11448
SplitVOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
CallOnceOptionsBuilder Builder
Definition schema_generated.h:10206
CustomQuantizationT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
SoftmaxOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
MirrorPadOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
int32_t dense_size() const
Definition schema_generated.h:4492
CosOptionsBuilder Builder
Definition schema_generated.h:7586
void UnPackTo(EqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const flatbuffers::Vector< flatbuffers::Offset< tflite::SubGraph > > * subgraphs() const
Definition schema_generated.h:13183
static flatbuffers::Offset< MatrixDiagOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixDiagOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< QuantizationParameters > Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::SqueezeOptions * builtin_options_as_SqueezeOptions() const
Definition schema_generated.h:11789
static flatbuffers::Offset< SignatureDef > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignatureDefT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< NegOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< MulOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
AssignVariableOptionsT NativeTableType
Definition schema_generated.h:11075
void UnPackTo(CosOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
MirrorPadOptionsT NativeTableType
Definition schema_generated.h:9702
static flatbuffers::Offset< ReducerOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< HashtableImportOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableImportOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
UnidirectionalSequenceLSTMOptionsT NativeTableType
Definition schema_generated.h:6456
static flatbuffers::Offset< ExpOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< DepthToSpaceOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthToSpaceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const flatbuffers::Vector< float > * max() const
Definition schema_generated.h:4153
void UnPackTo(OperatorCodeT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< ArgMaxOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const flatbuffers::Vector< int32_t > * inputs() const
Definition schema_generated.h:11689
static flatbuffers::Offset< VarHandleOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const VarHandleOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
NegOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
int32_t init_subgraph_index() const
Definition schema_generated.h:10210
MatrixSetDiagOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(SqueezeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
NegOptionsBuilder Builder
Definition schema_generated.h:8418
void UnPackTo(EmbeddingLookupSparseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::WhereOptions * builtin_options_as_WhereOptions() const
Definition schema_generated.h:11954
const tflite::VarHandleOptions * builtin_options_as_VarHandleOptions() const
Definition schema_generated.h:12032
static flatbuffers::Offset< SquareOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
ResizeNearestNeighborOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
ReverseSequenceOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::ATan2Options * builtin_options_as_ATan2Options() const
Definition schema_generated.h:12065
static flatbuffers::Offset< Conv3DOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv3DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
UnsortedSegmentSumOptionsBuilder Builder
Definition schema_generated.h:11409
static flatbuffers::Offset< UnsortedSegmentSumOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< SparsityParameters > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparsityParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
HashtableFindOptionsBuilder Builder
Definition schema_generated.h:10843
GatherNdOptionsBuilder Builder
Definition schema_generated.h:9884
SpaceToBatchNDOptionsT NativeTableType
Definition schema_generated.h:6982
IfOptionsBuilder Builder
Definition schema_generated.h:10144
void UnPackTo(ExpandDimsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
LocalResponseNormalizationOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::IfOptions * builtin_options_as_IfOptions() const
Definition schema_generated.h:11975
const tflite::DensifyOptions * builtin_options_as_DensifyOptions() const
Definition schema_generated.h:11996
Uint8VectorT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::SoftmaxOptions * builtin_options_as_SoftmaxOptions() const
Definition schema_generated.h:11726
const flatbuffers::Vector< uint8_t > * values() const
Definition schema_generated.h:4418
MetadataBuilder Builder
Definition schema_generated.h:12895
const tflite::ReverseV2Options * builtin_options_as_ReverseV2Options() const
Definition schema_generated.h:11942
QuantizationParametersBuilder Builder
Definition schema_generated.h:4140
const tflite::FillOptions * builtin_options_as_FillOptions() const
Definition schema_generated.h:11903
OneHotOptionsT NativeTableType
Definition schema_generated.h:9106
const tflite::MatrixSetDiagOptions * builtin_options_as_MatrixSetDiagOptions() const
Definition schema_generated.h:11969
LSHProjectionOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
SignOptionsT NativeTableType
Definition schema_generated.h:11525
const flatbuffers::Vector< uint8_t > * custom() const
Definition schema_generated.h:4076
const tflite::SelectOptions * builtin_options_as_SelectOptions() const
Definition schema_generated.h:11840
void UnPackTo(MirrorPadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< DivOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
uint32_t tensor_index() const
Definition schema_generated.h:12978
void UnPackTo(LessEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
AddNOptionsT NativeTableType
Definition schema_generated.h:9844
const tflite::LessOptions * builtin_options_as_LessOptions() const
Definition schema_generated.h:11822
LogSoftmaxOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< ResizeBilinearOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
FakeQuantOptionsBuilder Builder
Definition schema_generated.h:8923
DimensionMetadataT NativeTableType
Definition schema_generated.h:4479
MetadataT NativeTableType
Definition schema_generated.h:12894
const tflite::UnidirectionalSequenceLSTMOptions * builtin_options_as_UnidirectionalSequenceLSTMOptions() const
Definition schema_generated.h:11912
OneHotOptionsBuilder Builder
Definition schema_generated.h:9107
LocalResponseNormalizationOptionsT NativeTableType
Definition schema_generated.h:6273
const void * details() const
Definition schema_generated.h:4165
MatrixSetDiagOptionsBuilder Builder
Definition schema_generated.h:10103
static flatbuffers::Offset< RankOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::LessEqualOptions * builtin_options_as_LessEqualOptions() const
Definition schema_generated.h:11837
DynamicUpdateSliceOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< WhileOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
ResizeBilinearOptionsT NativeTableType
Definition schema_generated.h:6666
ZerosLikeOptionsT NativeTableType
Definition schema_generated.h:9454
static flatbuffers::Offset< UnsortedSegmentMaxOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
LessOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< LogicalAndOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
FloorModOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(SliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
int32_t axis() const
Definition schema_generated.h:6047
int32_t dilation_w_factor() const
Definition schema_generated.h:5031
CumsumOptionsT NativeTableType
Definition schema_generated.h:10629
tflite::TensorType type() const
Definition schema_generated.h:4736
const tflite::FloorDivOptions * builtin_options_as_FloorDivOptions() const
Definition schema_generated.h:11894
const tflite::DepthwiseConv2DOptions * builtin_options_as_DepthwiseConv2DOptions() const
Definition schema_generated.h:11705
Pool2DOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
SparseToDenseOptionsBuilder Builder
Definition schema_generated.h:8660
void UnPackTo(Conv3DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
GeluOptionsBuilder Builder
Definition schema_generated.h:11241
SparsityParametersT NativeTableType
Definition schema_generated.h:4633
bool Verify(flatbuffers::Verifier &verifier) const
Definition schema_generated.h:4079
const tflite::DynamicUpdateSliceOptions * builtin_options_as_DynamicUpdateSliceOptions() const
Definition schema_generated.h:12050
int32_t ngram_size() const
Definition schema_generated.h:7070
void UnPackTo(LogicalAndOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::SpaceToDepthOptions * builtin_options_as_SpaceToDepthOptions() const
Definition schema_generated.h:11756
UnsortedSegmentMinOptionsT NativeTableType
Definition schema_generated.h:11486
static flatbuffers::Offset< GreaterOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
SparsityParametersBuilder Builder
Definition schema_generated.h:4634
const flatbuffers::Vector< uint16_t > * values() const
Definition schema_generated.h:4355
CosOptionsT NativeTableType
Definition schema_generated.h:7585
LeakyReluOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
PadV2OptionsBuilder Builder
Definition schema_generated.h:6882
static flatbuffers::Offset< SubGraph > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
NonMaxSuppressionV5OptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
CallOnceOptionsT NativeTableType
Definition schema_generated.h:10205
void UnPackTo(CallOnceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
DepthwiseConv2DOptionsT NativeTableType
Definition schema_generated.h:5353
const tflite::SparseToDenseOptions * builtin_options_as_SparseToDenseOptions() const
Definition schema_generated.h:11849
void UnPackTo(Uint16VectorT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::LogicalOrOptions * builtin_options_as_LogicalOrOptions() const
Definition schema_generated.h:11879
PadOptionsBuilder Builder
Definition schema_generated.h:6843
void UnPackTo(RandomOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const flatbuffers::Vector< flatbuffers::Offset< tflite::Tensor > > * tensors() const
Definition schema_generated.h:12719
MaximumMinimumOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
SpaceToDepthOptionsT NativeTableType
Definition schema_generated.h:7135
const tflite::PadV2Options * builtin_options_as_PadV2Options() const
Definition schema_generated.h:11828
const tflite::QuantizationParameters * quantization() const
Definition schema_generated.h:4851
const flatbuffers::String * shared_name() const
Definition schema_generated.h:10970
PadV2OptionsT NativeTableType
Definition schema_generated.h:6881
void UnPackTo(DynamicUpdateSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
WhereOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< ReverseSequenceOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
int32_t quantized_dimension() const
Definition schema_generated.h:4172
BufferBuilder Builder
Definition schema_generated.h:12831
const flatbuffers::Vector< int32_t > * values() const
Definition schema_generated.h:4293
int32_t version() const
Definition schema_generated.h:11582
WhileOptionsBuilder Builder
Definition schema_generated.h:10259
static flatbuffers::Offset< CumsumOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const CumsumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
ConcatEmbeddingsOptionsT NativeTableType
Definition schema_generated.h:5467
const tflite::EmbeddingLookupSparseOptions * builtin_options_as_EmbeddingLookupSparseOptions() const
Definition schema_generated.h:11759
MaximumMinimumOptionsBuilder Builder
Definition schema_generated.h:8080
ScatterNdOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
OperatorBuilder Builder
Definition schema_generated.h:11674
ZerosLikeOptionsBuilder Builder
Definition schema_generated.h:9455
const tflite::NonMaxSuppressionV4Options * builtin_options_as_NonMaxSuppressionV4Options() const
Definition schema_generated.h:11984
StridedSliceOptionsBuilder Builder
Definition schema_generated.h:7848
void UnPackTo(PackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(TopKV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(RankOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::UnsortedSegmentMinOptions * builtin_options_as_UnsortedSegmentMinOptions() const
Definition schema_generated.h:12059
void UnPackTo(SpaceToDepthOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
CastOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
DynamicUpdateSliceOptionsT NativeTableType
Definition schema_generated.h:11291
bool validate_indices() const
Definition schema_generated.h:8664
FillOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
RankOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(TransposeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
AddOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
TopKV2OptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::PowOptions * builtin_options_as_PowOptions() const
Definition schema_generated.h:11867
const flatbuffers::Vector< int32_t > * embedding_dim_per_channel() const
Definition schema_generated.h:5480
ReverseV2OptionsBuilder Builder
Definition schema_generated.h:9806
VarHandleOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
QuantizationParametersT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::WhileOptions * builtin_options_as_WhileOptions() const
Definition schema_generated.h:11978
ResizeNearestNeighborOptionsT NativeTableType
Definition schema_generated.h:6729
PowOptionsBuilder Builder
Definition schema_generated.h:8880
NonMaxSuppressionV5OptionsBuilder Builder
Definition schema_generated.h:10359
const tflite::RNNOptions * builtin_options_as_RNNOptions() const
Definition schema_generated.h:11720
const tflite::L2NormOptions * builtin_options_as_L2NormOptions() const
Definition schema_generated.h:11735
static flatbuffers::Offset< ZerosLikeOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::BidirectionalSequenceLSTMOptions * builtin_options_as_BidirectionalSequenceLSTMOptions() const
Definition schema_generated.h:11906
ATan2OptionsT NativeTableType
Definition schema_generated.h:11447
static flatbuffers::Offset< PadOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
Int32VectorT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
ResizeNearestNeighborOptionsBuilder Builder
Definition schema_generated.h:6730
float beta() const
Definition schema_generated.h:5993
ConcatEmbeddingsOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
Uint16VectorT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
BroadcastToOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< Uint16Vector > Pack(flatbuffers::FlatBufferBuilder &_fbb, const Uint16VectorT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
ReadVariableOptionsT NativeTableType
Definition schema_generated.h:11036
static flatbuffers::Offset< RNNOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
CastOptionsT NativeTableType
Definition schema_generated.h:7979
void UnPackTo(ExpOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(ZerosLikeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
BufferT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
bool align_corners() const
Definition schema_generated.h:6672
static flatbuffers::Offset< CallOnceOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOnceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
FloorDivOptionsBuilder Builder
Definition schema_generated.h:9377
UnidirectionalSequenceLSTMOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(LogicalOrOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< SelectV2Options > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
TensorMapT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
Rfft2dOptionsBuilder Builder
Definition schema_generated.h:10730
tflite::BuiltinOperator builtin_code() const
Definition schema_generated.h:11585
const tflite::SkipGramOptions * builtin_options_as_SkipGramOptions() const
Definition schema_generated.h:11753
static flatbuffers::Offset< Buffer > Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const flatbuffers::String * description() const
Definition schema_generated.h:13186
VariantSubTypeT NativeTableType
Definition schema_generated.h:4726
void UnPackTo(ShapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
DepthToSpaceOptionsBuilder Builder
Definition schema_generated.h:7188
void UnPackTo(UnsortedSegmentMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
LSTMOptionsBuilder Builder
Definition schema_generated.h:6360
static flatbuffers::Offset< NonMaxSuppressionV5Options > Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV5OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
Pool2DOptionsT NativeTableType
Definition schema_generated.h:5245
static flatbuffers::Offset< FullyConnectedOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< AbsOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
QuantizeOptionsT NativeTableType
Definition schema_generated.h:10063
tflite::CustomOptionsFormat custom_options_format() const
Definition schema_generated.h:12074
static flatbuffers::Offset< SequenceRNNOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
ModelT NativeTableType
Definition schema_generated.h:13165
RangeOptionsBuilder Builder
Definition schema_generated.h:9572
ReverseSequenceOptionsBuilder Builder
Definition schema_generated.h:9964
void UnPackTo(UnsortedSegmentMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
Rfft2dOptionsT NativeTableType
Definition schema_generated.h:10729
const tflite::PackOptions * builtin_options_as_PackOptions() const
Definition schema_generated.h:11876
MulOptionsBuilder Builder
Definition schema_generated.h:6167
void UnPackTo(StridedSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
BidirectionalSequenceLSTMOptionsBuilder Builder
Definition schema_generated.h:6564
SpaceToDepthOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
tflite::SparseIndexVector array_segments_type() const
Definition schema_generated.h:4495
const tflite::BatchMatMulOptions * builtin_options_as_BatchMatMulOptions() const
Definition schema_generated.h:12002
void UnPackTo(CustomQuantizationT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
SparsityParametersT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(ResizeNearestNeighborOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::LogSoftmaxOptions * builtin_options_as_LogSoftmaxOptions() const
Definition schema_generated.h:11807
int64_t seed() const
Definition schema_generated.h:11122
TensorT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(Conv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
MatrixDiagOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(DensifyOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
UnsortedSegmentMaxOptionsBuilder Builder
Definition schema_generated.h:11370
GreaterOptionsBuilder Builder
Definition schema_generated.h:8262
IfOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const flatbuffers::Vector< flatbuffers::Offset< tflite::VariantSubType > > * variant_tensors() const
Definition schema_generated.h:4866
const tflite::GeluOptions * builtin_options_as_GeluOptions() const
Definition schema_generated.h:12047
Conv3DOptionsBuilder Builder
Definition schema_generated.h:5119
tflite::FullyConnectedOptionsWeightsFormat weights_format() const
Definition schema_generated.h:5917
RangeOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
UnidirectionalSequenceLSTMOptionsBuilder Builder
Definition schema_generated.h:6457
SquareOptionsT NativeTableType
Definition schema_generated.h:9415
tflite::Padding padding() const
Definition schema_generated.h:5019
static flatbuffers::Offset< ReshapeOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
SquaredDifferenceOptionsT NativeTableType
Definition schema_generated.h:9662
static flatbuffers::Offset< WhereOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(NonMaxSuppressionV4OptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
tflite::SparseIndexVector array_indices_type() const
Definition schema_generated.h:4511
const tflite::RankOptions * builtin_options_as_RankOptions() const
Definition schema_generated.h:11957
static flatbuffers::Offset< RangeOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::ArgMaxOptions * builtin_options_as_ArgMaxOptions() const
Definition schema_generated.h:11819
tflite::ActivationFunctionType fused_activation_function() const
Definition schema_generated.h:5028
BroadcastToOptionsT NativeTableType
Definition schema_generated.h:10690
DimensionMetadataBuilder Builder
Definition schema_generated.h:4480
HashtableImportOptionsBuilder Builder
Definition schema_generated.h:10882
PackOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(RNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
L2NormOptionsBuilder Builder
Definition schema_generated.h:6219
void UnPackTo(QuantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
ArgMinOptionsBuilder Builder
Definition schema_generated.h:8211
ExpOptionsBuilder Builder
Definition schema_generated.h:7547
QuantizeOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
ShapeOptionsT NativeTableType
Definition schema_generated.h:8789
ShapeOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::Uint8Vector * array_segments_as_Uint8Vector() const
Definition schema_generated.h:4508
void UnPackTo(SkipGramOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::AddOptions * builtin_options_as_AddOptions() const
Definition schema_generated.h:11732
bool reverse() const
Definition schema_generated.h:10638
MatrixDiagOptionsT NativeTableType
Definition schema_generated.h:10024
void UnPackTo(HashtableFindOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< TransposeConvOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
TensorMapBuilder Builder
Definition schema_generated.h:12970
const tflite::ScatterNdOptions * builtin_options_as_ScatterNdOptions() const
Definition schema_generated.h:11990
int32_t num_channels() const
Definition schema_generated.h:5474
const tflite::HashtableFindOptions * builtin_options_as_HashtableFindOptions() const
Definition schema_generated.h:12023
const flatbuffers::Vector< float > * boundaries() const
Definition schema_generated.h:11183
void UnPackTo(ResizeBilinearOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
SequenceRNNOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::DivOptions * builtin_options_as_DivOptions() const
Definition schema_generated.h:11786
const tflite::HashtableSizeOptions * builtin_options_as_HashtableSizeOptions() const
Definition schema_generated.h:12029
const tflite::MulOptions * builtin_options_as_MulOptions() const
Definition schema_generated.h:11762
void UnPackTo(SquareOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
int32_t values_count() const
Definition schema_generated.h:9011
OperatorT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
SignOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::ConcatEmbeddingsOptions * builtin_options_as_ConcatEmbeddingsOptions() const
Definition schema_generated.h:11708
RandomOptionsBuilder Builder
Definition schema_generated.h:11117
FullyConnectedOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
L2NormOptionsT NativeTableType
Definition schema_generated.h:6218
EqualOptionsT NativeTableType
Definition schema_generated.h:8710
SignatureDefT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
tflite::LSHProjectionType type() const
Definition schema_generated.h:5560
const tflite::ReshapeOptions * builtin_options_as_ReshapeOptions() const
Definition schema_generated.h:11750
TopKV2OptionsT NativeTableType
Definition schema_generated.h:7353
SelectV2OptionsT NativeTableType
Definition schema_generated.h:10436
HashtableOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
BidirectionalSequenceRNNOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::Int32Vector * array_indices_as_Int32Vector() const
Definition schema_generated.h:4518
static flatbuffers::Offset< BidirectionalSequenceLSTMOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::GreaterOptions * builtin_options_as_GreaterOptions() const
Definition schema_generated.h:11831
NonMaxSuppressionV5OptionsT NativeTableType
Definition schema_generated.h:10358
AbsOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
int32_t num_splits() const
Definition schema_generated.h:7744
int32_t radius() const
Definition schema_generated.h:6281
GreaterEqualOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
PackOptionsT NativeTableType
Definition schema_generated.h:9005
LogicalNotOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< ConcatEmbeddingsOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(VarHandleOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
BidirectionalSequenceRNNOptionsBuilder Builder
Definition schema_generated.h:5822
ExpandDimsOptionsT NativeTableType
Definition schema_generated.h:8619
static flatbuffers::Offset< LogicalNotOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
DepthToSpaceOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
BufferT NativeTableType
Definition schema_generated.h:12830
const tflite::BatchToSpaceNDOptions * builtin_options_as_BatchToSpaceNDOptions() const
Definition schema_generated.h:11771
static flatbuffers::Offset< MaximumMinimumOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::NonMaxSuppressionV5Options * builtin_options_as_NonMaxSuppressionV5Options() const
Definition schema_generated.h:11987
ReshapeOptionsT NativeTableType
Definition schema_generated.h:6921
LogSoftmaxOptionsT NativeTableType
Definition schema_generated.h:7938
DequantizeOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(SignatureDefT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
Conv2DOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(MatrixSetDiagOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
FullyConnectedOptionsT NativeTableType
Definition schema_generated.h:5906
AddOptionsBuilder Builder
Definition schema_generated.h:6105
void UnPackTo(ScatterNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
ReadVariableOptionsBuilder Builder
Definition schema_generated.h:11037
RankOptionsT NativeTableType
Definition schema_generated.h:8840
Int32VectorBuilder Builder
Definition schema_generated.h:4289
const tflite::StridedSliceOptions * builtin_options_as_StridedSliceOptions() const
Definition schema_generated.h:11795
SpaceToBatchNDOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
LogicalAndOptionsBuilder Builder
Definition schema_generated.h:9236
bool time_major() const
Definition schema_generated.h:5753
const tflite::AssignVariableOptions * builtin_options_as_AssignVariableOptions() const
Definition schema_generated.h:12038
void UnPackTo(BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
bool narrow_range() const
Definition schema_generated.h:8939
void UnPackTo(FullyConnectedOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
tflite::LSTMKernelType kernel_type() const
Definition schema_generated.h:6377
const tflite::FullyConnectedOptions * builtin_options_as_FullyConnectedOptions() const
Definition schema_generated.h:11723
static flatbuffers::Offset< SegmentSumOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SegmentSumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
ReshapeOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
bool pot_scale_int16() const
Definition schema_generated.h:6113
HashtableImportOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
DequantizeOptionsT NativeTableType
Definition schema_generated.h:8040
int32_t shrink_axis_mask() const
Definition schema_generated.h:7868
LogSoftmaxOptionsBuilder Builder
Definition schema_generated.h:7939
void UnPackTo(DepthToSpaceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
ConcatenationOptionsT NativeTableType
Definition schema_generated.h:6041
void UnPackTo(SVDFOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(MetadataT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
SVDFOptionsBuilder Builder
Definition schema_generated.h:5610
Conv2DOptionsT NativeTableType
Definition schema_generated.h:5009
GatherNdOptionsT NativeTableType
Definition schema_generated.h:9883
const tflite::CustomQuantization * details_as_CustomQuantization() const
Definition schema_generated.h:4169
tflite::BuiltinOptions builtin_options_type() const
Definition schema_generated.h:11695
tflite::MirrorPadMode mode() const
Definition schema_generated.h:9707
static flatbuffers::Offset< LSHProjectionOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< ExpandDimsOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
BroadcastToOptionsBuilder Builder
Definition schema_generated.h:10691
const tflite::HardSwishOptions * builtin_options_as_HardSwishOptions() const
Definition schema_generated.h:11972
void UnPackTo(LeakyReluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
DivOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
Rfft2dOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
uint32_t subgraph() const
Definition schema_generated.h:6796
void UnPackTo(ATan2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
SpaceToBatchNDOptionsBuilder Builder
Definition schema_generated.h:6983
Uint16VectorBuilder Builder
Definition schema_generated.h:4351
SliceOptionsBuilder Builder
Definition schema_generated.h:8496
static flatbuffers::Offset< SquaredDifferenceOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(AddNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
TransposeConvOptionsBuilder Builder
Definition schema_generated.h:8539
SegmentSumOptionsT NativeTableType
Definition schema_generated.h:10514
SegmentSumOptionsBuilder Builder
Definition schema_generated.h:10515
const flatbuffers::String * container() const
Definition schema_generated.h:10967
static flatbuffers::Offset< SqueezeOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const flatbuffers::Vector< uint8_t > * mutating_variable_inputs() const
Definition schema_generated.h:12077
static flatbuffers::Offset< SelectOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
TransposeOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
PowOptionsT NativeTableType
Definition schema_generated.h:8879
static flatbuffers::Offset< Pool2DOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< DequantizeOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< GatherNdOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
void UnPackTo(ReadVariableOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(CastOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< HashtableFindOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const HashtableFindOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
int32_t body_subgraph_index() const
Definition schema_generated.h:10267
void UnPackTo(TransposeConvOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
BatchToSpaceNDOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(FillOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
CastOptionsBuilder Builder
Definition schema_generated.h:7980
SVDFOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
MulOptionsT NativeTableType
Definition schema_generated.h:6166
void UnPackTo(ArgMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
CumsumOptionsBuilder Builder
Definition schema_generated.h:10630
const tflite::Rfft2dOptions * builtin_options_as_Rfft2dOptions() const
Definition schema_generated.h:12014
NotEqualOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
int32_t batch_dim() const
Definition schema_generated.h:9972
tflite::QuantizationDetails details_type() const
Definition schema_generated.h:4162
const tflite::CosOptions * builtin_options_as_CosOptions() const
Definition schema_generated.h:11951
static flatbuffers::Offset< Tensor > Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
BidirectionalSequenceLSTMOptionsT NativeTableType
Definition schema_generated.h:6563
const tflite::CastOptions * builtin_options_as_CastOptions() const
Definition schema_generated.h:11810
static flatbuffers::Offset< CallOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
BucketizeOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
void UnPackTo(ArgMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< CastOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::SparsityParameters * sparsity() const
Definition schema_generated.h:4857
ExpOptionsT NativeTableType
Definition schema_generated.h:7546
const tflite::Int32Vector * array_segments_as_Int32Vector() const
Definition schema_generated.h:4502
static flatbuffers::Offset< SplitOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
int32_t seq_dim() const
Definition schema_generated.h:9969
tflite::TensorType key_dtype() const
Definition schema_generated.h:10781
PowOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
MatrixSetDiagOptionsT NativeTableType
Definition schema_generated.h:10102
uint32_t opcode_index() const
Definition schema_generated.h:11686
FullyConnectedOptionsBuilder Builder
Definition schema_generated.h:5907
CallOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::MirrorPadOptions * builtin_options_as_MirrorPadOptions() const
Definition schema_generated.h:11930
const tflite::SliceOptions * builtin_options_as_SliceOptions() const
Definition schema_generated.h:11843
static flatbuffers::Offset< FakeQuantOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< BucketizeOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const BucketizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
SelectOptionsBuilder Builder
Definition schema_generated.h:8457
void UnPackTo(HashtableSizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
GeluOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
bool has_rank() const
Definition schema_generated.h:4739
HardSwishOptionsT NativeTableType
Definition schema_generated.h:9196
DensifyOptionsBuilder Builder
Definition schema_generated.h:10476
int32_t ellipsis_mask() const
Definition schema_generated.h:7862
void UnPackTo(TensorMapT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
UnsortedSegmentSumOptionsT NativeTableType
Definition schema_generated.h:11408
OneHotOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
const tflite::CumsumOptions * builtin_options_as_CumsumOptions() const
Definition schema_generated.h:12005
ScatterNdOptionsT NativeTableType
Definition schema_generated.h:10397
const flatbuffers::Vector< int32_t > * traversal_order() const
Definition schema_generated.h:4640
int32_t block_size() const
Definition schema_generated.h:7140
int32_t then_subgraph_index() const
Definition schema_generated.h:10149
int32_t stride_h() const
Definition schema_generated.h:5025
const tflite::QuantizeOptions * builtin_options_as_QuantizeOptions() const
Definition schema_generated.h:11966
DepthToSpaceOptionsT NativeTableType
Definition schema_generated.h:7187
void UnPackTo(BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
ReverseV2OptionsT NativeTableType
Definition schema_generated.h:9805
void UnPackTo(Uint8VectorT *_o, const flatbuffers::resolver_function_t *_resolver=nullptr) const
SplitVOptionsBuilder Builder
Definition schema_generated.h:7792
bool is_variable() const
Definition schema_generated.h:4854
ModelBuilder Builder
Definition schema_generated.h:13166
DepthwiseConv2DOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
SubGraphT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
static flatbuffers::Offset< UnsortedSegmentMinOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnsortedSegmentMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
const tflite::PadOptions * builtin_options_as_PadOptions() const
Definition schema_generated.h:11765
ResizeBilinearOptionsBuilder Builder
Definition schema_generated.h:6667
RandomOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
SubOptionsBuilder Builder
Definition schema_generated.h:7241
CallOnceOptionsT * UnPack(const flatbuffers::resolver_function_t *_resolver=nullptr) const
HashtableSizeOptionsT NativeTableType
Definition schema_generated.h:10920
StridedSliceOptionsT NativeTableType
Definition schema_generated.h:7847
static flatbuffers::Offset< NonMaxSuppressionV4Options > Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV4OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
static flatbuffers::Offset< UnidirectionalSequenceLSTMOptions > Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher=nullptr)
CustomQuantizationT NativeTableType
Definition schema_generated.h:4071
SubGraphT NativeTableType
Definition schema_generated.h:12710
const tflite::GatherOptions * builtin_options_as_GatherOptions() const
Definition schema_generated.h:11768
float bias() const
Definition schema_generated.h:6284
Definition schema_generated.h:11685
FakeQuantOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8971
flatbuffers::uoffset_t start_
Definition schema_generated.h:8958
void add_min(float min)
Definition schema_generated.h:8959
flatbuffers::Offset< FakeQuantOptions > Finish()
Definition schema_generated.h:8975
void add_num_bits(int32_t num_bits)
Definition schema_generated.h:8965
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8957
FakeQuantOptions Table
Definition schema_generated.h:8956
void add_max(float max)
Definition schema_generated.h:8962
void add_narrow_range(bool narrow_range)
Definition schema_generated.h:8968
Definition schema_generated.h:11643
FakeQuantOptions TableType
Definition schema_generated.h:8914
Definition schema_generated.h:12234
FillOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9508
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9506
flatbuffers::Offset< FillOptions > Finish()
Definition schema_generated.h:9512
flatbuffers::uoffset_t start_
Definition schema_generated.h:9507
FillOptions Table
Definition schema_generated.h:9505
Definition schema_generated.h:12218
FillOptions TableType
Definition schema_generated.h:9489
Definition schema_generated.h:12117
FloorDivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9391
flatbuffers::uoffset_t start_
Definition schema_generated.h:9390
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9389
FloorDivOptions Table
Definition schema_generated.h:9388
flatbuffers::Offset< FloorDivOptions > Finish()
Definition schema_generated.h:9395
Definition schema_generated.h:12101
FloorDivOptions TableType
Definition schema_generated.h:9372
Definition schema_generated.h:12273
flatbuffers::Offset< FloorModOptions > Finish()
Definition schema_generated.h:9551
FloorModOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9547
FloorModOptions Table
Definition schema_generated.h:9544
flatbuffers::uoffset_t start_
Definition schema_generated.h:9546
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9545
Definition schema_generated.h:12257
FloorModOptions TableType
Definition schema_generated.h:9528
Definition schema_generated.h:8642
void add_keep_num_dims(bool keep_num_dims)
Definition schema_generated.h:5949
flatbuffers::Offset< FullyConnectedOptions > Finish()
Definition schema_generated.h:5959
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
Definition schema_generated.h:5952
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:5943
FullyConnectedOptions Table
Definition schema_generated.h:5940
FullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:5955
void add_weights_format(tflite::FullyConnectedOptionsWeightsFormat weights_format)
Definition schema_generated.h:5946
flatbuffers::uoffset_t start_
Definition schema_generated.h:5942
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:5941
Definition schema_generated.h:8594
FullyConnectedOptions TableType
Definition schema_generated.h:5898
Definition schema_generated.h:12624
GatherNdOptions Table
Definition schema_generated.h:9895
flatbuffers::uoffset_t start_
Definition schema_generated.h:9897
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9896
flatbuffers::Offset< GatherNdOptions > Finish()
Definition schema_generated.h:9902
GatherNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9898
Definition schema_generated.h:12608
GatherNdOptions TableType
Definition schema_generated.h:9879
Definition schema_generated.h:10177
GatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7479
flatbuffers::Offset< GatherOptions > Finish()
Definition schema_generated.h:7483
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7471
void add_batch_dims(int32_t batch_dims)
Definition schema_generated.h:7476
flatbuffers::uoffset_t start_
Definition schema_generated.h:7472
void add_axis(int32_t axis)
Definition schema_generated.h:7473
GatherOptions Table
Definition schema_generated.h:7470
Definition schema_generated.h:10147
GatherOptions TableType
Definition schema_generated.h:7440
Definition schema_generated.h:13988
void add_approximate(bool approximate)
Definition schema_generated.h:11262
GeluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11265
GeluOptions Table
Definition schema_generated.h:11259
flatbuffers::uoffset_t start_
Definition schema_generated.h:11261
flatbuffers::Offset< GeluOptions > Finish()
Definition schema_generated.h:11269
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:11260
Definition schema_generated.h:13964
GeluOptions TableType
Definition schema_generated.h:11235
Definition schema_generated.h:11030
flatbuffers::Offset< GreaterEqualOptions > Finish()
Definition schema_generated.h:8319
GreaterEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8315
GreaterEqualOptions Table
Definition schema_generated.h:8312
flatbuffers::uoffset_t start_
Definition schema_generated.h:8314
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8313
Definition schema_generated.h:11014
GreaterEqualOptions TableType
Definition schema_generated.h:8296
Definition schema_generated.h:10991
flatbuffers::uoffset_t start_
Definition schema_generated.h:8275
GreaterOptions Table
Definition schema_generated.h:8273
GreaterOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8276
flatbuffers::Offset< GreaterOptions > Finish()
Definition schema_generated.h:8280
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8274
Definition schema_generated.h:10975
GreaterOptions TableType
Definition schema_generated.h:8257
Definition schema_generated.h:11937
flatbuffers::uoffset_t start_
Definition schema_generated.h:9210
flatbuffers::Offset< HardSwishOptions > Finish()
Definition schema_generated.h:9215
HardSwishOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9211
HardSwishOptions Table
Definition schema_generated.h:9208
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9209
Definition schema_generated.h:11921
HardSwishOptions TableType
Definition schema_generated.h:9192
Definition schema_generated.h:13583
flatbuffers::uoffset_t start_
Definition schema_generated.h:10856
HashtableFindOptions Table
Definition schema_generated.h:10854
flatbuffers::Offset< HashtableFindOptions > Finish()
Definition schema_generated.h:10861
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10855
HashtableFindOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10857
Definition schema_generated.h:13567
HashtableFindOptions TableType
Definition schema_generated.h:10838
Definition schema_generated.h:13622
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10894
HashtableImportOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10896
flatbuffers::uoffset_t start_
Definition schema_generated.h:10895
flatbuffers::Offset< HashtableImportOptions > Finish()
Definition schema_generated.h:10900
HashtableImportOptions Table
Definition schema_generated.h:10893
Definition schema_generated.h:13606
HashtableImportOptions TableType
Definition schema_generated.h:10877
Definition schema_generated.h:13529
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10801
flatbuffers::uoffset_t start_
Definition schema_generated.h:10802
HashtableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10812
HashtableOptions Table
Definition schema_generated.h:10800
void add_table_id(int32_t table_id)
Definition schema_generated.h:10803
void add_value_dtype(tflite::TensorType value_dtype)
Definition schema_generated.h:10809
void add_key_dtype(tflite::TensorType key_dtype)
Definition schema_generated.h:10806
flatbuffers::Offset< HashtableOptions > Finish()
Definition schema_generated.h:10816
Definition schema_generated.h:13493
HashtableOptions TableType
Definition schema_generated.h:10764
Definition schema_generated.h:13661
HashtableSizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10935
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10933
HashtableSizeOptions Table
Definition schema_generated.h:10932
flatbuffers::uoffset_t start_
Definition schema_generated.h:10934
flatbuffers::Offset< HashtableSizeOptions > Finish()
Definition schema_generated.h:10939
Definition schema_generated.h:13645
HashtableSizeOptions TableType
Definition schema_generated.h:10916
Definition schema_generated.h:12896
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10168
flatbuffers::Offset< IfOptions > Finish()
Definition schema_generated.h:10180
IfOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10176
flatbuffers::uoffset_t start_
Definition schema_generated.h:10169
IfOptions Table
Definition schema_generated.h:10167
void add_then_subgraph_index(int32_t then_subgraph_index)
Definition schema_generated.h:10170
void add_else_subgraph_index(int32_t else_subgraph_index)
Definition schema_generated.h:10173
Definition schema_generated.h:12866
IfOptions TableType
Definition schema_generated.h:10137
Definition schema_generated.h:5239
Int32VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:4314
flatbuffers::uoffset_t start_
Definition schema_generated.h:4310
flatbuffers::Offset< Int32Vector > Finish()
Definition schema_generated.h:4318
Int32Vector Table
Definition schema_generated.h:4308
void add_values(flatbuffers::Offset< flatbuffers::Vector< int32_t > > values)
Definition schema_generated.h:4311
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:4309
Definition schema_generated.h:5214
std::vector< int32_t > values
Definition schema_generated.h:4284
Int32Vector TableType
Definition schema_generated.h:4283
Definition schema_generated.h:8944
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6238
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:6240
flatbuffers::Offset< L2NormOptions > Finish()
Definition schema_generated.h:6247
flatbuffers::uoffset_t start_
Definition schema_generated.h:6239
L2NormOptions Table
Definition schema_generated.h:6237
L2NormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6243
Definition schema_generated.h:8920
L2NormOptions TableType
Definition schema_generated.h:6213
Definition schema_generated.h:8270
void add_type(tflite::LSHProjectionType type)
Definition schema_generated.h:5577
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:5575
LSHProjectionOptions Table
Definition schema_generated.h:5574
flatbuffers::Offset< LSHProjectionOptions > Finish()
Definition schema_generated.h:5584
LSHProjectionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:5580
flatbuffers::uoffset_t start_
Definition schema_generated.h:5576
Definition schema_generated.h:8246
LSHProjectionOptions TableType
Definition schema_generated.h:5550
Definition schema_generated.h:9105
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
Definition schema_generated.h:6413
LSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6416
flatbuffers::Offset< LSTMOptions > Finish()
Definition schema_generated.h:6420
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6399
void add_cell_clip(float cell_clip)
Definition schema_generated.h:6404
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:6401
void add_proj_clip(float proj_clip)
Definition schema_generated.h:6407
void add_kernel_type(tflite::LSTMKernelType kernel_type)
Definition schema_generated.h:6410
LSTMOptions Table
Definition schema_generated.h:6398
flatbuffers::uoffset_t start_
Definition schema_generated.h:6400
Definition schema_generated.h:9057
LSTMOptions TableType
Definition schema_generated.h:6350
Definition schema_generated.h:12359
flatbuffers::uoffset_t start_
Definition schema_generated.h:9632
flatbuffers::Offset< LeakyReluOptions > Finish()
Definition schema_generated.h:9640
LeakyReluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9636
LeakyReluOptions Table
Definition schema_generated.h:9630
void add_alpha(float alpha)
Definition schema_generated.h:9633
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9631
Definition schema_generated.h:12335
LeakyReluOptions TableType
Definition schema_generated.h:9606
Definition schema_generated.h:11108
LessEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8393
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8391
flatbuffers::Offset< LessEqualOptions > Finish()
Definition schema_generated.h:8397
flatbuffers::uoffset_t start_
Definition schema_generated.h:8392
LessEqualOptions Table
Definition schema_generated.h:8390
Definition schema_generated.h:11092
LessEqualOptions TableType
Definition schema_generated.h:8374
Definition schema_generated.h:11069
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8352
flatbuffers::uoffset_t start_
Definition schema_generated.h:8353
flatbuffers::Offset< LessOptions > Finish()
Definition schema_generated.h:8358
LessOptions Table
Definition schema_generated.h:8351
LessOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8354
Definition schema_generated.h:11053
LessOptions TableType
Definition schema_generated.h:8335
Definition schema_generated.h:9014
void add_radius(int32_t radius)
Definition schema_generated.h:6310
LocalResponseNormalizationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6322
LocalResponseNormalizationOptions Table
Definition schema_generated.h:6307
void add_beta(float beta)
Definition schema_generated.h:6319
void add_alpha(float alpha)
Definition schema_generated.h:6316
flatbuffers::Offset< LocalResponseNormalizationOptions > Finish()
Definition schema_generated.h:6326
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6308
flatbuffers::uoffset_t start_
Definition schema_generated.h:6309
void add_bias(float bias)
Definition schema_generated.h:6313
Definition schema_generated.h:8972
LocalResponseNormalizationOptions TableType
Definition schema_generated.h:6265
Definition schema_generated.h:10668
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7951
flatbuffers::Offset< LogSoftmaxOptions > Finish()
Definition schema_generated.h:7957
LogSoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7953
flatbuffers::uoffset_t start_
Definition schema_generated.h:7952
LogSoftmaxOptions Table
Definition schema_generated.h:7950
Definition schema_generated.h:10652
LogSoftmaxOptions TableType
Definition schema_generated.h:7934
Definition schema_generated.h:11976
flatbuffers::Offset< LogicalAndOptions > Finish()
Definition schema_generated.h:9254
flatbuffers::uoffset_t start_
Definition schema_generated.h:9249
LogicalAndOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9250
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9248
LogicalAndOptions Table
Definition schema_generated.h:9247
Definition schema_generated.h:11960
LogicalAndOptions TableType
Definition schema_generated.h:9231
Definition schema_generated.h:12015
LogicalNotOptions Table
Definition schema_generated.h:9286
flatbuffers::Offset< LogicalNotOptions > Finish()
Definition schema_generated.h:9293
flatbuffers::uoffset_t start_
Definition schema_generated.h:9288
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9287
LogicalNotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9289
Definition schema_generated.h:11999
LogicalNotOptions TableType
Definition schema_generated.h:9270
Definition schema_generated.h:11807
flatbuffers::uoffset_t start_
Definition schema_generated.h:9080
flatbuffers::Offset< LogicalOrOptions > Finish()
Definition schema_generated.h:9085
LogicalOrOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9081
LogicalOrOptions Table
Definition schema_generated.h:9078
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9079
Definition schema_generated.h:11791
LogicalOrOptions TableType
Definition schema_generated.h:9062
Definition schema_generated.h:12765
flatbuffers::Offset< MatrixDiagOptions > Finish()
Definition schema_generated.h:10043
MatrixDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10039
flatbuffers::uoffset_t start_
Definition schema_generated.h:10038
MatrixDiagOptions Table
Definition schema_generated.h:10036
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10037
Definition schema_generated.h:12749
MatrixDiagOptions TableType
Definition schema_generated.h:10020
Definition schema_generated.h:12843
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10115
MatrixSetDiagOptions Table
Definition schema_generated.h:10114
MatrixSetDiagOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10117
flatbuffers::Offset< MatrixSetDiagOptions > Finish()
Definition schema_generated.h:10121
flatbuffers::uoffset_t start_
Definition schema_generated.h:10116
Definition schema_generated.h:12827
MatrixSetDiagOptions TableType
Definition schema_generated.h:10098
Definition schema_generated.h:10809
MaximumMinimumOptions Table
Definition schema_generated.h:8091
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8092
flatbuffers::uoffset_t start_
Definition schema_generated.h:8093
MaximumMinimumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8094
flatbuffers::Offset< MaximumMinimumOptions > Finish()
Definition schema_generated.h:8098
Definition schema_generated.h:10793
MaximumMinimumOptions TableType
Definition schema_generated.h:8075
Definition schema_generated.h:16096
flatbuffers::uoffset_t start_
Definition schema_generated.h:12921
flatbuffers::Offset< Metadata > Finish()
Definition schema_generated.h:12932
MetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:12928
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:12920
Metadata Table
Definition schema_generated.h:12919
void add_buffer(uint32_t buffer)
Definition schema_generated.h:12925
void add_name(flatbuffers::Offset< flatbuffers::String > name)
Definition schema_generated.h:12922
Definition schema_generated.h:16065
Metadata TableType
Definition schema_generated.h:12888
Definition schema_generated.h:12450
flatbuffers::uoffset_t start_
Definition schema_generated.h:9723
void add_mode(tflite::MirrorPadMode mode)
Definition schema_generated.h:9724
MirrorPadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9727
MirrorPadOptions Table
Definition schema_generated.h:9721
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9722
flatbuffers::Offset< MirrorPadOptions > Finish()
Definition schema_generated.h:9731
Definition schema_generated.h:12426
MirrorPadOptions TableType
Definition schema_generated.h:9697
Definition schema_generated.h:16408
void add_metadata_buffer(flatbuffers::Offset< flatbuffers::Vector< int32_t > > metadata_buffer)
Definition schema_generated.h:13249
Model Table
Definition schema_generated.h:13231
ModelBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:13258
void add_buffers(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::Buffer > > > buffers)
Definition schema_generated.h:13246
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:13232
void add_description(flatbuffers::Offset< flatbuffers::String > description)
Definition schema_generated.h:13243
flatbuffers::Offset< Model > Finish()
Definition schema_generated.h:13262
void add_signature_defs(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::SignatureDef > > > signature_defs)
Definition schema_generated.h:13255
void add_version(uint32_t version)
Definition schema_generated.h:13234
void add_metadata(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::Metadata > > > metadata)
Definition schema_generated.h:13252
void add_subgraphs(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::SubGraph > > > subgraphs)
Definition schema_generated.h:13240
void add_operator_codes(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::OperatorCode > > > operator_codes)
Definition schema_generated.h:13237
flatbuffers::uoffset_t start_
Definition schema_generated.h:13233
Definition schema_generated.h:16326
std::vector< std::unique_ptr< tflite::BufferT > > buffers
Definition schema_generated.h:13154
std::vector< std::unique_ptr< tflite::SignatureDefT > > signature_defs
Definition schema_generated.h:13157
std::vector< std::unique_ptr< tflite::MetadataT > > metadata
Definition schema_generated.h:13156
ModelT(ModelT &&) FLATBUFFERS_NOEXCEPT=default
ModelT & operator=(ModelT o) FLATBUFFERS_NOEXCEPT
Definition schema_generated.h:17229
std::vector< std::unique_ptr< tflite::OperatorCodeT > > operator_codes
Definition schema_generated.h:13151
Model TableType
Definition schema_generated.h:13149
ModelT()=default
std::vector< std::unique_ptr< tflite::SubGraphT > > subgraphs
Definition schema_generated.h:13152
Definition schema_generated.h:8892
flatbuffers::uoffset_t start_
Definition schema_generated.h:6187
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6186
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:6188
MulOptions Table
Definition schema_generated.h:6185
MulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6191
flatbuffers::Offset< MulOptions > Finish()
Definition schema_generated.h:6195
Definition schema_generated.h:8868
MulOptions TableType
Definition schema_generated.h:6161
Definition schema_generated.h:11147
flatbuffers::Offset< NegOptions > Finish()
Definition schema_generated.h:8436
flatbuffers::uoffset_t start_
Definition schema_generated.h:8431
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8430
NegOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8432
NegOptions Table
Definition schema_generated.h:8429
Definition schema_generated.h:11131
NegOptions TableType
Definition schema_generated.h:8413
Definition schema_generated.h:13060
flatbuffers::uoffset_t start_
Definition schema_generated.h:10333
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10332
NonMaxSuppressionV4Options Table
Definition schema_generated.h:10331
NonMaxSuppressionV4OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10334
flatbuffers::Offset< NonMaxSuppressionV4Options > Finish()
Definition schema_generated.h:10338
Definition schema_generated.h:13044
NonMaxSuppressionV4Options TableType
Definition schema_generated.h:10315
Definition schema_generated.h:13099
flatbuffers::uoffset_t start_
Definition schema_generated.h:10372
NonMaxSuppressionV5OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10373
flatbuffers::Offset< NonMaxSuppressionV5Options > Finish()
Definition schema_generated.h:10377
NonMaxSuppressionV5Options Table
Definition schema_generated.h:10370
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10371
Definition schema_generated.h:13083
NonMaxSuppressionV5Options TableType
Definition schema_generated.h:10354
Definition schema_generated.h:11490
flatbuffers::Offset< NotEqualOptions > Finish()
Definition schema_generated.h:8768
NotEqualOptions Table
Definition schema_generated.h:8761
NotEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8764
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8762
flatbuffers::uoffset_t start_
Definition schema_generated.h:8763
Definition schema_generated.h:11474
NotEqualOptions TableType
Definition schema_generated.h:8745
Definition schema_generated.h:11854
OneHotOptions Table
Definition schema_generated.h:9125
flatbuffers::uoffset_t start_
Definition schema_generated.h:9127
void add_axis(int32_t axis)
Definition schema_generated.h:9128
OneHotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9131
flatbuffers::Offset< OneHotOptions > Finish()
Definition schema_generated.h:9135
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9126
Definition schema_generated.h:11830
OneHotOptions TableType
Definition schema_generated.h:9101
Definition schema_generated.h:15723
OperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:12630
flatbuffers::uoffset_t start_
Definition schema_generated.h:12602
flatbuffers::Offset< Operator > Finish()
Definition schema_generated.h:12634
void add_outputs(flatbuffers::Offset< flatbuffers::Vector< int32_t > > outputs)
Definition schema_generated.h:12609
void add_builtin_options_type(tflite::BuiltinOptions builtin_options_type)
Definition schema_generated.h:12612
void add_custom_options_format(tflite::CustomOptionsFormat custom_options_format)
Definition schema_generated.h:12621
void add_mutating_variable_inputs(flatbuffers::Offset< flatbuffers::Vector< uint8_t > > mutating_variable_inputs)
Definition schema_generated.h:12624
Operator Table
Definition schema_generated.h:12600
void add_intermediates(flatbuffers::Offset< flatbuffers::Vector< int32_t > > intermediates)
Definition schema_generated.h:12627
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:12601
void add_opcode_index(uint32_t opcode_index)
Definition schema_generated.h:12603
void add_inputs(flatbuffers::Offset< flatbuffers::Vector< int32_t > > inputs)
Definition schema_generated.h:12606
void add_custom_options(flatbuffers::Offset< flatbuffers::Vector< uint8_t > > custom_options)
Definition schema_generated.h:12618
void add_builtin_options(flatbuffers::Offset< void > builtin_options)
Definition schema_generated.h:12615
Definition schema_generated.h:14540
void add_version(int32_t version)
Definition schema_generated.h:11612
OperatorCode Table
Definition schema_generated.h:11603
void add_builtin_code(tflite::BuiltinOperator builtin_code)
Definition schema_generated.h:11615
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:11604
void add_custom_code(flatbuffers::Offset< flatbuffers::String > custom_code)
Definition schema_generated.h:11609
OperatorCodeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11618
void add_deprecated_builtin_code(int8_t deprecated_builtin_code)
Definition schema_generated.h:11606
flatbuffers::uoffset_t start_
Definition schema_generated.h:11605
flatbuffers::Offset< OperatorCode > Finish()
Definition schema_generated.h:11622
Definition schema_generated.h:14497
OperatorCode TableType
Definition schema_generated.h:11560
Definition schema_generated.h:14598
Operator TableType
Definition schema_generated.h:11661
Definition schema_generated.h:11758
void add_axis(int32_t axis)
Definition schema_generated.h:9035
flatbuffers::Offset< PackOptions > Finish()
Definition schema_generated.h:9042
void add_values_count(int32_t values_count)
Definition schema_generated.h:9032
PackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9038
PackOptions Table
Definition schema_generated.h:9029
flatbuffers::uoffset_t start_
Definition schema_generated.h:9031
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9030
Definition schema_generated.h:11728
PackOptions TableType
Definition schema_generated.h:8999
Definition schema_generated.h:9561
PadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6857
flatbuffers::Offset< PadOptions > Finish()
Definition schema_generated.h:6861
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6855
PadOptions Table
Definition schema_generated.h:6854
flatbuffers::uoffset_t start_
Definition schema_generated.h:6856
Definition schema_generated.h:9545
PadOptions TableType
Definition schema_generated.h:6838
Definition schema_generated.h:9600
PadV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6896
flatbuffers::Offset< PadV2Options > Finish()
Definition schema_generated.h:6900
flatbuffers::uoffset_t start_
Definition schema_generated.h:6895
PadV2Options Table
Definition schema_generated.h:6893
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6894
Definition schema_generated.h:9584
PadV2Options TableType
Definition schema_generated.h:6877
Definition schema_generated.h:7985
void add_stride_h(int32_t stride_h)
Definition schema_generated.h:5298
void add_stride_w(int32_t stride_w)
Definition schema_generated.h:5295
Pool2DOptions Table
Definition schema_generated.h:5289
void add_padding(tflite::Padding padding)
Definition schema_generated.h:5292
void add_filter_height(int32_t filter_height)
Definition schema_generated.h:5304
flatbuffers::uoffset_t start_
Definition schema_generated.h:5291
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:5307
void add_filter_width(int32_t filter_width)
Definition schema_generated.h:5301
Pool2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:5310
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:5290
flatbuffers::Offset< Pool2DOptions > Finish()
Definition schema_generated.h:5314
Definition schema_generated.h:7931
Pool2DOptions TableType
Definition schema_generated.h:5235
Definition schema_generated.h:11620
flatbuffers::uoffset_t start_
Definition schema_generated.h:8893
PowOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8894
PowOptions Table
Definition schema_generated.h:8891
flatbuffers::Offset< PowOptions > Finish()
Definition schema_generated.h:8898
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8892
Definition schema_generated.h:11604
PowOptions TableType
Definition schema_generated.h:8875
Definition schema_generated.h:778
static const QuantizationDetails enum_value
Definition schema_generated.h:687
Definition schema_generated.h:794
const tflite::CustomQuantizationT * AsCustomQuantization() const
Definition schema_generated.h:736
QuantizationDetailsUnion & operator=(QuantizationDetailsUnion &&u) FLATBUFFERS_NOEXCEPT
Definition schema_generated.h:713
QuantizationDetailsUnion & operator=(const QuantizationDetailsUnion &u)
Definition schema_generated.h:711
tflite::CustomQuantizationT * AsCustomQuantization()
Definition schema_generated.h:732
QuantizationDetailsUnion()
Definition schema_generated.h:706
void Reset()
Definition schema_generated.h:17346
QuantizationDetailsUnion(QuantizationDetailsUnion &&u) FLATBUFFERS_NOEXCEPT
Definition schema_generated.h:707
static void * UnPack(const void *obj, QuantizationDetails type, const flatbuffers::resolver_function_t *resolver)
Definition schema_generated.h:17313
void * value
Definition schema_generated.h:704
flatbuffers::Offset< void > Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher=nullptr) const
Definition schema_generated.h:17324
QuantizationDetails type
Definition schema_generated.h:703
void Set(T &&val)
Definition schema_generated.h:720
~QuantizationDetailsUnion()
Definition schema_generated.h:715
Definition schema_generated.h:786
static const QuantizationDetails enum_value
Definition schema_generated.h:695
Definition schema_generated.h:5132
void add_min(flatbuffers::Offset< flatbuffers::Vector< float > > min)
Definition schema_generated.h:4204
void add_max(flatbuffers::Offset< flatbuffers::Vector< float > > max)
Definition schema_generated.h:4207
void add_details(flatbuffers::Offset< void > details)
Definition schema_generated.h:4219
void add_details_type(tflite::QuantizationDetails details_type)
Definition schema_generated.h:4216
void add_quantized_dimension(int32_t quantized_dimension)
Definition schema_generated.h:4222
void add_scale(flatbuffers::Offset< flatbuffers::Vector< float > > scale)
Definition schema_generated.h:4210
void add_zero_point(flatbuffers::Offset< flatbuffers::Vector< int64_t > > zero_point)
Definition schema_generated.h:4213
flatbuffers::uoffset_t start_
Definition schema_generated.h:4203
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:4202
QuantizationParameters Table
Definition schema_generated.h:4201
QuantizationParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:4225
flatbuffers::Offset< QuantizationParameters > Finish()
Definition schema_generated.h:4229
Definition schema_generated.h:5060
std::vector< float > min
Definition schema_generated.h:4130
QuantizationParameters TableType
Definition schema_generated.h:4129
std::vector< int64_t > zero_point
Definition schema_generated.h:4133
int32_t quantized_dimension
Definition schema_generated.h:4135
std::vector< float > max
Definition schema_generated.h:4131
tflite::QuantizationDetailsUnion details
Definition schema_generated.h:4134
std::vector< float > scale
Definition schema_generated.h:4132
Definition schema_generated.h:12804
QuantizeOptions Table
Definition schema_generated.h:10075
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10076
QuantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10078
flatbuffers::Offset< QuantizeOptions > Finish()
Definition schema_generated.h:10082
flatbuffers::uoffset_t start_
Definition schema_generated.h:10077
Definition schema_generated.h:12788
QuantizeOptions TableType
Definition schema_generated.h:10059
Definition schema_generated.h:8402
flatbuffers::uoffset_t start_
Definition schema_generated.h:5708
RNNOptions Table
Definition schema_generated.h:5706
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
Definition schema_generated.h:5712
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:5709
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:5707
RNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:5715
flatbuffers::Offset< RNNOptions > Finish()
Definition schema_generated.h:5719
Definition schema_generated.h:8372
RNNOptions TableType
Definition schema_generated.h:5676
Definition schema_generated.h:13869
flatbuffers::uoffset_t start_
Definition schema_generated.h:11142
RandomOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11149
void add_seed2(int64_t seed2)
Definition schema_generated.h:11146
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:11141
void add_seed(int64_t seed)
Definition schema_generated.h:11143
flatbuffers::Offset< RandomOptions > Finish()
Definition schema_generated.h:11153
RandomOptions Table
Definition schema_generated.h:11140
Definition schema_generated.h:13839
RandomOptions TableType
Definition schema_generated.h:11110
Definition schema_generated.h:12312
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9584
flatbuffers::uoffset_t start_
Definition schema_generated.h:9585
RangeOptions Table
Definition schema_generated.h:9583
flatbuffers::Offset< RangeOptions > Finish()
Definition schema_generated.h:9590
RangeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9586
Definition schema_generated.h:12296
RangeOptions TableType
Definition schema_generated.h:9567
Definition schema_generated.h:11581
flatbuffers::Offset< RankOptions > Finish()
Definition schema_generated.h:8859
RankOptions Table
Definition schema_generated.h:8852
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8853
flatbuffers::uoffset_t start_
Definition schema_generated.h:8854
RankOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8855
Definition schema_generated.h:11565
RankOptions TableType
Definition schema_generated.h:8836
Definition schema_generated.h:13777
ReadVariableOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11051
ReadVariableOptions Table
Definition schema_generated.h:11048
flatbuffers::uoffset_t start_
Definition schema_generated.h:11050
flatbuffers::Offset< ReadVariableOptions > Finish()
Definition schema_generated.h:11055
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:11049
Definition schema_generated.h:13761
ReadVariableOptions TableType
Definition schema_generated.h:11032
Definition schema_generated.h:10351
void add_keep_dims(bool keep_dims)
Definition schema_generated.h:7647
flatbuffers::Offset< ReducerOptions > Finish()
Definition schema_generated.h:7654
ReducerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7650
flatbuffers::uoffset_t start_
Definition schema_generated.h:7646
ReducerOptions Table
Definition schema_generated.h:7644
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7645
Definition schema_generated.h:10327
ReducerOptions TableType
Definition schema_generated.h:7620
Definition schema_generated.h:9648
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6942
flatbuffers::Offset< ReshapeOptions > Finish()
Definition schema_generated.h:6951
ReshapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6947
flatbuffers::uoffset_t start_
Definition schema_generated.h:6943
ReshapeOptions Table
Definition schema_generated.h:6941
void add_new_shape(flatbuffers::Offset< flatbuffers::Vector< int32_t > > new_shape)
Definition schema_generated.h:6944
Definition schema_generated.h:9623
ReshapeOptions TableType
Definition schema_generated.h:6916
Definition schema_generated.h:9397
ResizeBilinearOptions Table
Definition schema_generated.h:6690
flatbuffers::uoffset_t start_
Definition schema_generated.h:6692
flatbuffers::Offset< ResizeBilinearOptions > Finish()
Definition schema_generated.h:6703
void add_half_pixel_centers(bool half_pixel_centers)
Definition schema_generated.h:6696
void add_align_corners(bool align_corners)
Definition schema_generated.h:6693
ResizeBilinearOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6699
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6691
Definition schema_generated.h:9367
ResizeBilinearOptions TableType
Definition schema_generated.h:6660
Definition schema_generated.h:9460
ResizeNearestNeighborOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6762
void add_half_pixel_centers(bool half_pixel_centers)
Definition schema_generated.h:6759
flatbuffers::uoffset_t start_
Definition schema_generated.h:6755
void add_align_corners(bool align_corners)
Definition schema_generated.h:6756
flatbuffers::Offset< ResizeNearestNeighborOptions > Finish()
Definition schema_generated.h:6766
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6754
ResizeNearestNeighborOptions Table
Definition schema_generated.h:6753
Definition schema_generated.h:9430
ResizeNearestNeighborOptions TableType
Definition schema_generated.h:6723
Definition schema_generated.h:12716
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9988
flatbuffers::uoffset_t start_
Definition schema_generated.h:9989
void add_batch_dim(int32_t batch_dim)
Definition schema_generated.h:9993
ReverseSequenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9996
void add_seq_dim(int32_t seq_dim)
Definition schema_generated.h:9990
ReverseSequenceOptions Table
Definition schema_generated.h:9987
flatbuffers::Offset< ReverseSequenceOptions > Finish()
Definition schema_generated.h:10000
Definition schema_generated.h:12686
ReverseSequenceOptions TableType
Definition schema_generated.h:9957
Definition schema_generated.h:12546
ReverseV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9820
flatbuffers::Offset< ReverseV2Options > Finish()
Definition schema_generated.h:9824
ReverseV2Options Table
Definition schema_generated.h:9817
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9818
flatbuffers::uoffset_t start_
Definition schema_generated.h:9819
Definition schema_generated.h:12530
ReverseV2Options TableType
Definition schema_generated.h:9801
Definition schema_generated.h:13470
flatbuffers::uoffset_t start_
Definition schema_generated.h:10743
Rfft2dOptions Table
Definition schema_generated.h:10741
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10742
flatbuffers::Offset< Rfft2dOptions > Finish()
Definition schema_generated.h:10748
Rfft2dOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10744
Definition schema_generated.h:13454
Rfft2dOptions TableType
Definition schema_generated.h:10725
Definition schema_generated.h:8334
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:5639
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:5644
SVDFOptions Table
Definition schema_generated.h:5638
SVDFOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:5650
void add_rank(int32_t rank)
Definition schema_generated.h:5641
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
Definition schema_generated.h:5647
flatbuffers::Offset< SVDFOptions > Finish()
Definition schema_generated.h:5654
flatbuffers::uoffset_t start_
Definition schema_generated.h:5640
Definition schema_generated.h:8298
SVDFOptions TableType
Definition schema_generated.h:5602
Definition schema_generated.h:13138
ScatterNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10412
ScatterNdOptions Table
Definition schema_generated.h:10409
flatbuffers::uoffset_t start_
Definition schema_generated.h:10411
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10410
flatbuffers::Offset< ScatterNdOptions > Finish()
Definition schema_generated.h:10416
Definition schema_generated.h:13122
ScatterNdOptions TableType
Definition schema_generated.h:10393
Definition schema_generated.h:13255
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10527
flatbuffers::Offset< SegmentSumOptions > Finish()
Definition schema_generated.h:10533
flatbuffers::uoffset_t start_
Definition schema_generated.h:10528
SegmentSumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10529
SegmentSumOptions Table
Definition schema_generated.h:10526
Definition schema_generated.h:13239
SegmentSumOptions TableType
Definition schema_generated.h:10510
Definition schema_generated.h:11186
flatbuffers::Offset< SelectOptions > Finish()
Definition schema_generated.h:8475
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8469
SelectOptions Table
Definition schema_generated.h:8468
flatbuffers::uoffset_t start_
Definition schema_generated.h:8470
SelectOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8471
Definition schema_generated.h:11170
SelectOptions TableType
Definition schema_generated.h:8452
Definition schema_generated.h:13177
flatbuffers::Offset< SelectV2Options > Finish()
Definition schema_generated.h:10455
flatbuffers::uoffset_t start_
Definition schema_generated.h:10450
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10449
SelectV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10451
SelectV2Options Table
Definition schema_generated.h:10448
Definition schema_generated.h:13161
SelectV2Options TableType
Definition schema_generated.h:10432
Definition schema_generated.h:8471
void add_time_major(bool time_major)
Definition schema_generated.h:5778
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
Definition schema_generated.h:5784
SequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:5787
flatbuffers::uoffset_t start_
Definition schema_generated.h:5777
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:5781
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:5776
flatbuffers::Offset< SequenceRNNOptions > Finish()
Definition schema_generated.h:5791
SequenceRNNOptions Table
Definition schema_generated.h:5775
Definition schema_generated.h:8435
SequenceRNNOptions TableType
Definition schema_generated.h:5739
Definition schema_generated.h:11537
ShapeOptions Table
Definition schema_generated.h:8808
flatbuffers::Offset< ShapeOptions > Finish()
Definition schema_generated.h:8818
flatbuffers::uoffset_t start_
Definition schema_generated.h:8810
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8809
void add_out_type(tflite::TensorType out_type)
Definition schema_generated.h:8811
ShapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8814
Definition schema_generated.h:11513
ShapeOptions TableType
Definition schema_generated.h:8784
Definition schema_generated.h:14266
flatbuffers::uoffset_t start_
Definition schema_generated.h:11539
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:11538
SignOptions Table
Definition schema_generated.h:11537
flatbuffers::Offset< SignOptions > Finish()
Definition schema_generated.h:11544
SignOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11540
Definition schema_generated.h:14250
SignOptions TableType
Definition schema_generated.h:11521
Definition schema_generated.h:16266
void add_inputs(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::TensorMap > > > inputs)
Definition schema_generated.h:13092
flatbuffers::Offset< SignatureDef > Finish()
Definition schema_generated.h:13108
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:13090
void add_subgraph_index(uint32_t subgraph_index)
Definition schema_generated.h:13101
void add_signature_key(flatbuffers::Offset< flatbuffers::String > signature_key)
Definition schema_generated.h:13098
SignatureDefBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:13104
flatbuffers::uoffset_t start_
Definition schema_generated.h:13091
SignatureDef Table
Definition schema_generated.h:13089
void add_outputs(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::TensorMap > > > outputs)
Definition schema_generated.h:13095
Definition schema_generated.h:16215
std::vector< std::unique_ptr< tflite::TensorMapT > > inputs
Definition schema_generated.h:13039
SignatureDefT(SignatureDefT &&) FLATBUFFERS_NOEXCEPT=default
std::vector< std::unique_ptr< tflite::TensorMapT > > outputs
Definition schema_generated.h:13040
SignatureDef TableType
Definition schema_generated.h:13038
SignatureDefT & operator=(SignatureDefT o) FLATBUFFERS_NOEXCEPT
Definition schema_generated.h:17170
Definition schema_generated.h:9799
void add_include_all_ngrams(bool include_all_ngrams)
Definition schema_generated.h:7101
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7093
void add_max_skip_size(int32_t max_skip_size)
Definition schema_generated.h:7098
flatbuffers::Offset< SkipGramOptions > Finish()
Definition schema_generated.h:7108
SkipGramOptions Table
Definition schema_generated.h:7092
SkipGramOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7104
void add_ngram_size(int32_t ngram_size)
Definition schema_generated.h:7095
flatbuffers::uoffset_t start_
Definition schema_generated.h:7094
Definition schema_generated.h:9763
SkipGramOptions TableType
Definition schema_generated.h:7056
Definition schema_generated.h:11225
SliceOptions Table
Definition schema_generated.h:8507
flatbuffers::Offset< SliceOptions > Finish()
Definition schema_generated.h:8514
SliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8510
flatbuffers::uoffset_t start_
Definition schema_generated.h:8509
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8508
Definition schema_generated.h:11209
SliceOptions TableType
Definition schema_generated.h:8491
Definition schema_generated.h:8714
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6008
SoftmaxOptions Table
Definition schema_generated.h:6007
flatbuffers::uoffset_t start_
Definition schema_generated.h:6009
flatbuffers::Offset< SoftmaxOptions > Finish()
Definition schema_generated.h:6017
SoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6013
void add_beta(float beta)
Definition schema_generated.h:6010
Definition schema_generated.h:8690
SoftmaxOptions TableType
Definition schema_generated.h:5983
Definition schema_generated.h:9701
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6995
flatbuffers::uoffset_t start_
Definition schema_generated.h:6996
SpaceToBatchNDOptions Table
Definition schema_generated.h:6994
SpaceToBatchNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6997
flatbuffers::Offset< SpaceToBatchNDOptions > Finish()
Definition schema_generated.h:7001
Definition schema_generated.h:9685
SpaceToBatchNDOptions TableType
Definition schema_generated.h:6978
Definition schema_generated.h:9861
SpaceToDepthOptions Table
Definition schema_generated.h:7154
void add_block_size(int32_t block_size)
Definition schema_generated.h:7157
SpaceToDepthOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7160
flatbuffers::uoffset_t start_
Definition schema_generated.h:7156
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7155
flatbuffers::Offset< SpaceToDepthOptions > Finish()
Definition schema_generated.h:7164
Definition schema_generated.h:9837
SpaceToDepthOptions TableType
Definition schema_generated.h:7130
Definition schema_generated.h:903
static const SparseIndexVector enum_value
Definition schema_generated.h:812
Definition schema_generated.h:935
SparseIndexVectorUnion()
Definition schema_generated.h:847
tflite::Int32VectorT * AsInt32Vector()
Definition schema_generated.h:873
static void * UnPack(const void *obj, SparseIndexVector type, const flatbuffers::resolver_function_t *resolver)
Definition schema_generated.h:17392
flatbuffers::Offset< void > Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher=nullptr) const
Definition schema_generated.h:17411
void Reset()
Definition schema_generated.h:17449
void Set(T &&val)
Definition schema_generated.h:861
const tflite::Int32VectorT * AsInt32Vector() const
Definition schema_generated.h:877
void * value
Definition schema_generated.h:845
tflite::Uint16VectorT * AsUint16Vector()
Definition schema_generated.h:881
SparseIndexVectorUnion(SparseIndexVectorUnion &&u) FLATBUFFERS_NOEXCEPT
Definition schema_generated.h:848
SparseIndexVector type
Definition schema_generated.h:844
const tflite::Uint8VectorT * AsUint8Vector() const
Definition schema_generated.h:893
tflite::Uint8VectorT * AsUint8Vector()
Definition schema_generated.h:889
~SparseIndexVectorUnion()
Definition schema_generated.h:856
const tflite::Uint16VectorT * AsUint16Vector() const
Definition schema_generated.h:885
SparseIndexVectorUnion & operator=(const SparseIndexVectorUnion &u)
Definition schema_generated.h:852
SparseIndexVectorUnion & operator=(SparseIndexVectorUnion &&u) FLATBUFFERS_NOEXCEPT
Definition schema_generated.h:854
Definition schema_generated.h:919
static const SparseIndexVector enum_value
Definition schema_generated.h:828
Definition schema_generated.h:11407
flatbuffers::Offset< SparseToDenseOptions > Finish()
Definition schema_generated.h:8688
SparseToDenseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8684
flatbuffers::uoffset_t start_
Definition schema_generated.h:8680
void add_validate_indices(bool validate_indices)
Definition schema_generated.h:8681
SparseToDenseOptions Table
Definition schema_generated.h:8678
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8679
Definition schema_generated.h:11383
SparseToDenseOptions TableType
Definition schema_generated.h:8654
Definition schema_generated.h:5597
SparsityParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:4678
void add_dim_metadata(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::DimensionMetadata > > > dim_metadata)
Definition schema_generated.h:4675
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:4667
SparsityParameters Table
Definition schema_generated.h:4666
void add_block_map(flatbuffers::Offset< flatbuffers::Vector< int32_t > > block_map)
Definition schema_generated.h:4672
void add_traversal_order(flatbuffers::Offset< flatbuffers::Vector< int32_t > > traversal_order)
Definition schema_generated.h:4669
flatbuffers::Offset< SparsityParameters > Finish()
Definition schema_generated.h:4682
flatbuffers::uoffset_t start_
Definition schema_generated.h:4668
Definition schema_generated.h:5553
SparsityParametersT & operator=(SparsityParametersT o) FLATBUFFERS_NOEXCEPT
Definition schema_generated.h:13521
SparsityParametersT(SparsityParametersT &&) FLATBUFFERS_NOEXCEPT=default
std::vector< std::unique_ptr< tflite::DimensionMetadataT > > dim_metadata
Definition schema_generated.h:4625
std::vector< int32_t > traversal_order
Definition schema_generated.h:4623
std::vector< int32_t > block_map
Definition schema_generated.h:4624
SparsityParameters TableType
Definition schema_generated.h:4622
Definition schema_generated.h:10465
flatbuffers::uoffset_t start_
Definition schema_generated.h:7760
SplitOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7764
flatbuffers::Offset< SplitOptions > Finish()
Definition schema_generated.h:7768
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7759
void add_num_splits(int32_t num_splits)
Definition schema_generated.h:7761
SplitOptions Table
Definition schema_generated.h:7758
Definition schema_generated.h:10441
SplitOptions TableType
Definition schema_generated.h:7734
Definition schema_generated.h:10517
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7811
flatbuffers::Offset< SplitVOptions > Finish()
Definition schema_generated.h:7820
flatbuffers::uoffset_t start_
Definition schema_generated.h:7812
SplitVOptions Table
Definition schema_generated.h:7810
SplitVOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7816
void add_num_splits(int32_t num_splits)
Definition schema_generated.h:7813
Definition schema_generated.h:10493
SplitVOptions TableType
Definition schema_generated.h:7786
Definition schema_generated.h:12156
flatbuffers::Offset< SquareOptions > Finish()
Definition schema_generated.h:9434
SquareOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9430
flatbuffers::uoffset_t start_
Definition schema_generated.h:9429
SquareOptions Table
Definition schema_generated.h:9427
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9428
Definition schema_generated.h:12140
SquareOptions TableType
Definition schema_generated.h:9411
Definition schema_generated.h:12403
SquaredDifferenceOptions Table
Definition schema_generated.h:9674
flatbuffers::uoffset_t start_
Definition schema_generated.h:9676
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9675
SquaredDifferenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9677
flatbuffers::Offset< SquaredDifferenceOptions > Finish()
Definition schema_generated.h:9681
Definition schema_generated.h:12387
SquaredDifferenceOptions TableType
Definition schema_generated.h:9658
Definition schema_generated.h:10404
flatbuffers::uoffset_t start_
Definition schema_generated.h:7699
SqueezeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7703
SqueezeOptions Table
Definition schema_generated.h:7697
flatbuffers::Offset< SqueezeOptions > Finish()
Definition schema_generated.h:7707
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7698
void add_squeeze_dims(flatbuffers::Offset< flatbuffers::Vector< int32_t > > squeeze_dims)
Definition schema_generated.h:7700
Definition schema_generated.h:10379
SqueezeOptions TableType
Definition schema_generated.h:7672
Definition schema_generated.h:10599
StridedSliceOptions Table
Definition schema_generated.h:7886
flatbuffers::Offset< StridedSliceOptions > Finish()
Definition schema_generated.h:7908
StridedSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7904
void add_ellipsis_mask(int32_t ellipsis_mask)
Definition schema_generated.h:7895
flatbuffers::uoffset_t start_
Definition schema_generated.h:7888
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7887
void add_shrink_axis_mask(int32_t shrink_axis_mask)
Definition schema_generated.h:7901
void add_end_mask(int32_t end_mask)
Definition schema_generated.h:7892
void add_begin_mask(int32_t begin_mask)
Definition schema_generated.h:7889
void add_new_axis_mask(int32_t new_axis_mask)
Definition schema_generated.h:7898
Definition schema_generated.h:10545
StridedSliceOptions TableType
Definition schema_generated.h:7838
Definition schema_generated.h:15907
void add_outputs(flatbuffers::Offset< flatbuffers::Vector< int32_t > > outputs)
Definition schema_generated.h:12765
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:12757
flatbuffers::Offset< SubGraph > Finish()
Definition schema_generated.h:12778
void add_name(flatbuffers::Offset< flatbuffers::String > name)
Definition schema_generated.h:12771
SubGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:12774
void add_inputs(flatbuffers::Offset< flatbuffers::Vector< int32_t > > inputs)
Definition schema_generated.h:12762
void add_operators(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::Operator > > > operators)
Definition schema_generated.h:12768
SubGraph Table
Definition schema_generated.h:12756
flatbuffers::uoffset_t start_
Definition schema_generated.h:12758
void add_tensors(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::Tensor > > > tensors)
Definition schema_generated.h:12759
Definition schema_generated.h:15848
SubGraph TableType
Definition schema_generated.h:12697
SubGraphT(SubGraphT &&) FLATBUFFERS_NOEXCEPT=default
std::vector< std::unique_ptr< tflite::TensorT > > tensors
Definition schema_generated.h:12698
SubGraphT()=default
std::vector< std::unique_ptr< tflite::OperatorT > > operators
Definition schema_generated.h:12701
SubGraphT & operator=(SubGraphT o) FLATBUFFERS_NOEXCEPT
Definition schema_generated.h:17029
Definition schema_generated.h:9971
flatbuffers::Offset< SubOptions > Finish()
Definition schema_generated.h:7277
flatbuffers::uoffset_t start_
Definition schema_generated.h:7266
SubOptions Table
Definition schema_generated.h:7264
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7265
void add_pot_scale_int16(bool pot_scale_int16)
Definition schema_generated.h:7270
SubOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7273
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:7267
Definition schema_generated.h:9941
SubOptions TableType
Definition schema_generated.h:7234
Definition schema_generated.h:5827
void add_shape_signature(flatbuffers::Offset< flatbuffers::Vector< int32_t > > shape_signature)
Definition schema_generated.h:4920
void add_buffer(uint32_t buffer)
Definition schema_generated.h:4905
void add_is_variable(bool is_variable)
Definition schema_generated.h:4914
void add_variant_tensors(flatbuffers::Offset< flatbuffers::Vector< flatbuffers::Offset< tflite::VariantSubType > > > variant_tensors)
Definition schema_generated.h:4926
TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:4929
void add_shape(flatbuffers::Offset< flatbuffers::Vector< int32_t > > shape)
Definition schema_generated.h:4899
void add_quantization(flatbuffers::Offset< tflite::QuantizationParameters > quantization)
Definition schema_generated.h:4911
void add_name(flatbuffers::Offset< flatbuffers::String > name)
Definition schema_generated.h:4908
void add_type(tflite::TensorType type)
Definition schema_generated.h:4902
Tensor Table
Definition schema_generated.h:4896
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:4897
void add_sparsity(flatbuffers::Offset< tflite::SparsityParameters > sparsity)
Definition schema_generated.h:4917
flatbuffers::Offset< Tensor > Finish()
Definition schema_generated.h:4933
flatbuffers::uoffset_t start_
Definition schema_generated.h:4898
void add_has_rank(bool has_rank)
Definition schema_generated.h:4923
Definition schema_generated.h:16171
flatbuffers::Offset< TensorMap > Finish()
Definition schema_generated.h:13007
TensorMapBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:13003
void add_tensor_index(uint32_t tensor_index)
Definition schema_generated.h:13000
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:12995
void add_name(flatbuffers::Offset< flatbuffers::String > name)
Definition schema_generated.h:12997
flatbuffers::uoffset_t start_
Definition schema_generated.h:12996
TensorMap Table
Definition schema_generated.h:12994
Definition schema_generated.h:16140
TensorMap TableType
Definition schema_generated.h:12963
Definition schema_generated.h:5738
TensorT(TensorT &&) FLATBUFFERS_NOEXCEPT=default
TensorT()=default
std::vector< std::unique_ptr< tflite::VariantSubTypeT > > variant_tensors
Definition schema_generated.h:4817
TensorT & operator=(TensorT o) FLATBUFFERS_NOEXCEPT
Definition schema_generated.h:13606
Tensor TableType
Definition schema_generated.h:4807
Definition schema_generated.h:10848
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8131
flatbuffers::Offset< TileOptions > Finish()
Definition schema_generated.h:8137
TileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8133
flatbuffers::uoffset_t start_
Definition schema_generated.h:8132
TileOptions Table
Definition schema_generated.h:8130
Definition schema_generated.h:10832
TileOptions TableType
Definition schema_generated.h:8114
Definition schema_generated.h:10072
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7366
TopKV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7368
flatbuffers::Offset< TopKV2Options > Finish()
Definition schema_generated.h:7372
flatbuffers::uoffset_t start_
Definition schema_generated.h:7367
TopKV2Options Table
Definition schema_generated.h:7365
Definition schema_generated.h:10056
TopKV2Options TableType
Definition schema_generated.h:7349
Definition schema_generated.h:11296
TransposeConvOptions Table
Definition schema_generated.h:8572
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:8584
TransposeConvOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:8587
void add_stride_w(int32_t stride_w)
Definition schema_generated.h:8578
flatbuffers::uoffset_t start_
Definition schema_generated.h:8574
void add_padding(tflite::Padding padding)
Definition schema_generated.h:8575
flatbuffers::Offset< TransposeConvOptions > Finish()
Definition schema_generated.h:8591
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:8573
void add_stride_h(int32_t stride_h)
Definition schema_generated.h:8581
Definition schema_generated.h:11248
TransposeConvOptions TableType
Definition schema_generated.h:8530
Definition schema_generated.h:10226
flatbuffers::uoffset_t start_
Definition schema_generated.h:7521
flatbuffers::Offset< TransposeOptions > Finish()
Definition schema_generated.h:7526
TransposeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:7522
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:7520
TransposeOptions Table
Definition schema_generated.h:7519
Definition schema_generated.h:10210
TransposeOptions TableType
Definition schema_generated.h:7503
Definition schema_generated.h:5301
flatbuffers::Offset< Uint16Vector > Finish()
Definition schema_generated.h:4380
void add_values(flatbuffers::Offset< flatbuffers::Vector< uint16_t > > values)
Definition schema_generated.h:4373
flatbuffers::uoffset_t start_
Definition schema_generated.h:4372
Uint16Vector Table
Definition schema_generated.h:4370
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:4371
Uint16VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:4376
Definition schema_generated.h:5276
Uint16Vector TableType
Definition schema_generated.h:4345
std::vector< uint16_t > values
Definition schema_generated.h:4346
Definition schema_generated.h:5364
flatbuffers::uoffset_t start_
Definition schema_generated.h:4435
Uint8Vector Table
Definition schema_generated.h:4433
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:4434
void add_values(flatbuffers::Offset< flatbuffers::Vector< uint8_t > > values)
Definition schema_generated.h:4436
Uint8VectorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:4439
flatbuffers::Offset< Uint8Vector > Finish()
Definition schema_generated.h:4443
Definition schema_generated.h:5339
std::vector< uint8_t > values
Definition schema_generated.h:4409
Uint8Vector TableType
Definition schema_generated.h:4408
Definition schema_generated.h:9207
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:6501
void add_cell_clip(float cell_clip)
Definition schema_generated.h:6506
void add_proj_clip(float proj_clip)
Definition schema_generated.h:6509
UnidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:6521
void add_diagonal_recurrent_tensors(bool diagonal_recurrent_tensors)
Definition schema_generated.h:6518
void add_time_major(bool time_major)
Definition schema_generated.h:6512
flatbuffers::uoffset_t start_
Definition schema_generated.h:6502
UnidirectionalSequenceLSTMOptions Table
Definition schema_generated.h:6500
flatbuffers::Offset< UnidirectionalSequenceLSTMOptions > Finish()
Definition schema_generated.h:6525
void add_asymmetric_quantize_inputs(bool asymmetric_quantize_inputs)
Definition schema_generated.h:6515
void add_fused_activation_function(tflite::ActivationFunctionType fused_activation_function)
Definition schema_generated.h:6503
Definition schema_generated.h:9153
UnidirectionalSequenceLSTMOptions TableType
Definition schema_generated.h:6446
Definition schema_generated.h:12502
UniqueOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9779
flatbuffers::uoffset_t start_
Definition schema_generated.h:9775
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9774
UniqueOptions Table
Definition schema_generated.h:9773
flatbuffers::Offset< UniqueOptions > Finish()
Definition schema_generated.h:9783
void add_idx_out_type(tflite::TensorType idx_out_type)
Definition schema_generated.h:9776
Definition schema_generated.h:12478
UniqueOptions TableType
Definition schema_generated.h:9749
Definition schema_generated.h:12068
flatbuffers::Offset< UnpackOptions > Finish()
Definition schema_generated.h:9352
UnpackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9348
flatbuffers::uoffset_t start_
Definition schema_generated.h:9341
void add_axis(int32_t axis)
Definition schema_generated.h:9345
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9340
UnpackOptions Table
Definition schema_generated.h:9339
void add_num(int32_t num)
Definition schema_generated.h:9342
Definition schema_generated.h:12038
UnpackOptions TableType
Definition schema_generated.h:9309
Definition schema_generated.h:14110
UnsortedSegmentMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11384
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:11382
UnsortedSegmentMaxOptions Table
Definition schema_generated.h:11381
flatbuffers::Offset< UnsortedSegmentMaxOptions > Finish()
Definition schema_generated.h:11388
flatbuffers::uoffset_t start_
Definition schema_generated.h:11383
Definition schema_generated.h:14094
UnsortedSegmentMaxOptions TableType
Definition schema_generated.h:11365
Definition schema_generated.h:14227
UnsortedSegmentMinOptions Table
Definition schema_generated.h:11498
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:11499
UnsortedSegmentMinOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11501
flatbuffers::Offset< UnsortedSegmentMinOptions > Finish()
Definition schema_generated.h:11505
flatbuffers::uoffset_t start_
Definition schema_generated.h:11500
Definition schema_generated.h:14211
UnsortedSegmentMinOptions TableType
Definition schema_generated.h:11482
Definition schema_generated.h:14071
UnsortedSegmentProdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11345
flatbuffers::uoffset_t start_
Definition schema_generated.h:11344
UnsortedSegmentProdOptions Table
Definition schema_generated.h:11342
flatbuffers::Offset< UnsortedSegmentProdOptions > Finish()
Definition schema_generated.h:11349
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:11343
Definition schema_generated.h:14055
UnsortedSegmentProdOptions TableType
Definition schema_generated.h:11326
Definition schema_generated.h:14149
flatbuffers::Offset< UnsortedSegmentSumOptions > Finish()
Definition schema_generated.h:11427
UnsortedSegmentSumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:11423
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:11421
UnsortedSegmentSumOptions Table
Definition schema_generated.h:11420
flatbuffers::uoffset_t start_
Definition schema_generated.h:11422
Definition schema_generated.h:14133
UnsortedSegmentSumOptions TableType
Definition schema_generated.h:11404
Definition schema_generated.h:13716
flatbuffers::Offset< VarHandleOptions > Finish()
Definition schema_generated.h:11000
VarHandleOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10996
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10988
VarHandleOptions Table
Definition schema_generated.h:10987
void add_shared_name(flatbuffers::Offset< flatbuffers::String > shared_name)
Definition schema_generated.h:10993
flatbuffers::uoffset_t start_
Definition schema_generated.h:10989
void add_container(flatbuffers::Offset< flatbuffers::String > container)
Definition schema_generated.h:10990
Definition schema_generated.h:13684
VarHandleOptions TableType
Definition schema_generated.h:10955
Definition schema_generated.h:5687
void add_shape(flatbuffers::Offset< flatbuffers::Vector< int32_t > > shape)
Definition schema_generated.h:4759
void add_has_rank(bool has_rank)
Definition schema_generated.h:4765
VariantSubTypeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:4768
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:4757
VariantSubType Table
Definition schema_generated.h:4756
void add_type(tflite::TensorType type)
Definition schema_generated.h:4762
flatbuffers::uoffset_t start_
Definition schema_generated.h:4758
flatbuffers::Offset< VariantSubType > Finish()
Definition schema_generated.h:4772
Definition schema_generated.h:5650
VariantSubType TableType
Definition schema_generated.h:4719
Definition schema_generated.h:12663
WhereOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9937
flatbuffers::uoffset_t start_
Definition schema_generated.h:9936
WhereOptions Table
Definition schema_generated.h:9934
flatbuffers::Offset< WhereOptions > Finish()
Definition schema_generated.h:9941
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9935
Definition schema_generated.h:12647
WhereOptions TableType
Definition schema_generated.h:9918
Definition schema_generated.h:13011
WhileOptions Table
Definition schema_generated.h:10282
WhileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:10291
flatbuffers::uoffset_t start_
Definition schema_generated.h:10284
flatbuffers::Offset< WhileOptions > Finish()
Definition schema_generated.h:10295
void add_cond_subgraph_index(int32_t cond_subgraph_index)
Definition schema_generated.h:10285
void add_body_subgraph_index(int32_t body_subgraph_index)
Definition schema_generated.h:10288
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:10283
Definition schema_generated.h:12981
WhileOptions TableType
Definition schema_generated.h:10252
Definition schema_generated.h:12195
flatbuffers::Offset< ZerosLikeOptions > Finish()
Definition schema_generated.h:9473
flatbuffers::uoffset_t start_
Definition schema_generated.h:9468
ZerosLikeOptions Table
Definition schema_generated.h:9466
flatbuffers::FlatBufferBuilder & fbb_
Definition schema_generated.h:9467
ZerosLikeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
Definition schema_generated.h:9469
Definition schema_generated.h:12179
ZerosLikeOptions TableType
Definition schema_generated.h:9450
flatbuffers::Offset< tflite::Operator > operators_[kMaxOperators]
Definition test_helpers.cpp:139
flatbuffers::Offset< tflite::Tensor > tensors_[kMaxTensors]
Definition test_helpers.cpp:143
flatbuffers::Offset< tflite::OperatorCode > operator_codes_[kMaxOperatorCodes]
Definition test_helpers.cpp:135
flatbuffers::FlatBufferBuilder * builder_
Definition test_helpers.cpp:132
flatbuffers::Offset< Metadata > metadata_[kMaxMetadatas]
Definition test_helpers.cpp:148
VT_SPARSITY
Definition schema_generated.h:4834
VT_DILATION_D_FACTOR
Definition schema_generated.h:5126
VT_ALPHA
Definition schema_generated.h:6278
VT_SEED
Definition schema_generated.h:11119
VT_BUFFER
Definition schema_generated.h:4830
VT_BUILTIN_OPTIONS
Definition schema_generated.h:11680
VT_RADIUS
Definition schema_generated.h:6276
VT_NUM_COLUMNS_PER_CHANNEL
Definition schema_generated.h:5471
VT_QUANTIZATION
Definition schema_generated.h:4832
VT_DETAILS
Definition schema_generated.h:4147
VT_SHAPE
Definition schema_generated.h:4729
VT_HAS_RANK
Definition schema_generated.h:4836
VT_ALIGN_CORNERS
Definition schema_generated.h:6669
VT_VALUES_COUNT
Definition schema_generated.h:9008
VT_SIGNATURE_KEY
Definition schema_generated.h:13055
VT_STRIDE_W
Definition schema_generated.h:5013
VT_SHAPE_SIGNATURE
Definition schema_generated.h:4835
VT_PADDING
Definition schema_generated.h:5012
VT_OPCODE_INDEX
Definition schema_generated.h:11676
VT_AXIS
Definition schema_generated.h:6044
VT_STRIDE_H
Definition schema_generated.h:5014
VT_FORMAT
Definition schema_generated.h:4482
VT_ZERO_POINT
Definition schema_generated.h:4145
VT_ASYMMETRIC_QUANTIZE_INPUTS
Definition schema_generated.h:6463
VT_ELLIPSIS_MASK
Definition schema_generated.h:7852
VT_ADJ_Y
Definition schema_generated.h:10560
VT_ADJ_X
Definition schema_generated.h:10559
VT_FUSED_ACTIVATION_FUNCTION
Definition schema_generated.h:5015
VT_VERSION
Definition schema_generated.h:11573
VT_ARRAY_SEGMENTS
Definition schema_generated.h:4485
VT_TENSORS
Definition schema_generated.h:12713
VT_WEIGHTS_FORMAT
Definition schema_generated.h:5910
VT_BUILTIN_OPTIONS_TYPE
Definition schema_generated.h:11679
VT_BUFFERS
Definition schema_generated.h:13172
VT_ARRAY_SEGMENTS_TYPE
Definition schema_generated.h:4484
VT_TRAVERSAL_ORDER
Definition schema_generated.h:4636
VT_SEQ_DIM
Definition schema_generated.h:9966
VT_COND_SUBGRAPH_INDEX
Definition schema_generated.h:10261
VT_END_MASK
Definition schema_generated.h:7851
VT_BLOCK_MAP
Definition schema_generated.h:4637
VT_RANK
Definition schema_generated.h:5612
VT_FILTER_HEIGHT
Definition schema_generated.h:5252
VT_METADATA
Definition schema_generated.h:13174
VT_CUSTOM_OPTIONS_FORMAT
Definition schema_generated.h:11682
VT_CUSTOM_OPTIONS
Definition schema_generated.h:11681
VT_OPERATORS
Definition schema_generated.h:12716
VT_CONTAINER
Definition schema_generated.h:10964
VT_MUTATING_VARIABLE_INPUTS
Definition schema_generated.h:11683
VT_SUBGRAPHS
Definition schema_generated.h:13170
VT_DENSE_SIZE
Definition schema_generated.h:4483
VT_TABLE_ID
Definition schema_generated.h:10774
VT_MIN
Definition schema_generated.h:4142
VT_CUSTOM_CODE
Definition schema_generated.h:11572
VT_KEY_DTYPE
Definition schema_generated.h:10775
VT_CELL_CLIP
Definition schema_generated.h:6363
VT_INPUTS
Definition schema_generated.h:11677
VT_ARRAY_INDICES_TYPE
Definition schema_generated.h:4486
VT_DEPRECATED_BUILTIN_CODE
Definition schema_generated.h:11571
VT_TYPE
Definition schema_generated.h:4730
VT_STRIDE_D
Definition schema_generated.h:5122
VT_DEPTH_MULTIPLIER
Definition schema_generated.h:5359
VT_OPERATOR_CODES
Definition schema_generated.h:13169
VT_EXCLUSIVE
Definition schema_generated.h:10632
VT_OUTPUTS
Definition schema_generated.h:11678
VT_NUM_CHANNELS
Definition schema_generated.h:5470
VT_FILTER_WIDTH
Definition schema_generated.h:5251
VT_NEW_AXIS_MASK
Definition schema_generated.h:7853
VT_MAX_SKIP_SIZE
Definition schema_generated.h:7067
VT_IN_DATA_TYPE
Definition schema_generated.h:7982
VT_NGRAM_SIZE
Definition schema_generated.h:7066
VT_BEGIN_MASK
Definition schema_generated.h:7850
VT_KEEP_NUM_DIMS
Definition schema_generated.h:5911
VT_SCALE
Definition schema_generated.h:4144
VT_NAME
Definition schema_generated.h:4831
VT_PROJ_CLIP
Definition schema_generated.h:6364
VT_BIAS
Definition schema_generated.h:6277
VT_METADATA_BUFFER
Definition schema_generated.h:13173
VT_DETAILS_TYPE
Definition schema_generated.h:4146
VT_NUM
Definition schema_generated.h:9318
VT_IS_VARIABLE
Definition schema_generated.h:4833
VT_MAX
Definition schema_generated.h:4143
VT_NUM_BITS
Definition schema_generated.h:8927
VT_DILATION_W_FACTOR
Definition schema_generated.h:5016
VT_DESCRIPTION
Definition schema_generated.h:13171
VT_THEN_SUBGRAPH_INDEX
Definition schema_generated.h:10146
VT_TIME_MAJOR
Definition schema_generated.h:5749
VT_MERGE_OUTPUTS
Definition schema_generated.h:5826
VT_KERNEL_TYPE
Definition schema_generated.h:6365
VT_INTERMEDIATES
Definition schema_generated.h:14625
VT_DILATION_H_FACTOR
Definition schema_generated.h:7704
VT_SHRINK_AXIS_MASK
Definition schema_generated.h:10563
int cond_subgraph_index
Definition while.cpp:35
int body_subgraph_index
Definition while.cpp:36
uint8_t value
Definition wm8960_regs.h:134